Random number in assembly
If you were using a real version of DOS (not EMU8086) @fuz method is the way you can do it, and it doesn't require interrupts. You just read the lower 16-bits of the 32-bit value at memory address 0x46c (0x00040:0x006c) in the BIOS Data Area(BDA). The value at that location is a 32-bit value representing the number of timer ticks since midnight. Unfortunately EMU8086 doesn't support this method.
To get a random number in EMU8086 with interrupts (system call) you can use Int 1ah/ah=0h:
TIME - GET SYSTEM TIME
AH = 00h Return: CX:DX = number of clock ticks since midnight AL = midnight flag, nonzero if midnight passed since time last read
You can then use that value and print it out. The value is semi random. You can print it out directly but it is preferable to pass it into a Pseudo-random Number Generator (PRNG) as a seed value. See section below for a basic LCG. Printing an integer is a separate issue although EMU8086 has a macro/function to do that. This code could produce a semi-random number between 1 and 10 and print it:
org 100h
include emu8086.inc
xor ax,ax ; xor register to itself same as zeroing register
int 1ah ; Int 1ah/ah=0 get timer ticks since midnight in CX:DX
mov ax,dx ; Use lower 16 bits (in DX) for random value
xor dx,dx ; Compute randval(DX) mod 10 to get num
mov bx,10 ; between 0 and 9
div bx ; Divide dx:ax by bx
inc dx ; DX = modulo from division
; Add 1 to give us # between 1 and 10 (not 0 to 9)
mov ax,dx ; Move to AX to print
call PRINT_NUM_UNS ; Print value in AX as unsigned
ret
DEFINE_PRINT_NUM_UNS ; Needed to support EMU8086 PRINT_NUM_UNS function
END
Each time you run this program it should print a number between 1 and 10. After we get the random value from the clock ticks we convert it to a number between 1 and 10. The code would have been similar to this pseudo code1:
unsigned char num = (get_rand_value() % 10) + 1
We divide by 10 and use the modulo (Modulo value will be between 0 and 9) and add 1 to make it a value between 1 and 10. get_rand_value is effectively the Int 1ah/AH=0 system call.
Note: The clock ticks is a semi random source, and the method to convert to a value from 1 to 10 suffers from modulo bias. I present the code above as a quick and dirty method but should be enough to get you started on your assignment.
It is possible to do this without issuing an INT instruction, but we are still using the interrupt vector table by doing an indirect FAR CALL to the code for the interrupt handler. I doubt this is what you had in mind when you asked the question whether it can be done without interrupts. An INT instruction under the hood pushes the current FLAGS register (using PUSHF) followed by the equivalent of a FAR CALL. Control is transferred to the FAR address at 0x0000:[interrupt_num * 4] which is in the interrupt vector table (IVT). When the interrupt routine finishes it will issue an IRET instruction which undoes the pushes, restores the flags and returns the instruction after the FAR CALL. The revised code could look like:
org 100h
include emu8086.inc
xor ax,ax ; xor register to itself same as zeroing register
mov es,ax ; Zero the ES register for use with FAR JMP below so that we
; can make a FAR CALL relative to bottom of Interrupt Vector Table
; in low memory (0x0000 to 0x03FF)
; Do a system call without the INT instruction
; This is advanced assembly and relies on the
; understanding of how INT/IRETD work. We fake a
; system call by pushing FLAGS and rather
; than use int 1ah we do a FAR CALL indirectly
; through the interrupt vector table in lower memory
pushf ; Push FLAGS
call far es:[1ah*4] ; Indirectly call Int 1ah/ah=0 through far pointer in IVT
; get timer ticks since midnight in CX:DX
mov ax,dx ; Use lower 16 bits (in DX) for random value
xor dx,dx ; Compute randval(DX) mod 10 to get num
mov bx,10 ; between 0 and 9
div bx
inc dx ; DX = modulo from division
; Add 1 to give us # between 1 and 10 (not 0 to 9)
mov ax,dx ; Move to AX to print
call PRINT_NUM_UNS ; Print value in AX as unsigned
ret
DEFINE_PRINT_NUM_UNS ; Macro from include file to make PRINT_NUM_UNS usable
END
Related Question? Possible Issues. Simple LCG PRNG
There is another question vaguely similar to this that was posted within a day of this one. If this assignment is related to the other one then it needs to be noted that you will encounter issues if you attempt to get random numbers in quick succession from the system timer tick. In my answer above I stated:
The value is semi random. You can print it out directly but it is preferable to pass it into a Pseudo Random Number Generator (PRNG) as a seed value.
The timer resolution is 18.2 times a second. That isn't a very high resolution and likely calling Int 1ah/ah=0 one after the other will result in the same number being returned or the second call having a higher chance of returning a higher value than the first. This can be resolved by creating a PRNG (like a simple LCG) and use the timer value once to seed it. For each value you need - you query the PRNG for the next value not the system time.
A simple LCG based PRNG can be found in this related Stackoverflow Answer. Based on that answer you can create an srandsystime function to seed the PRNG with the timer ticks, and a rand() function that returns the next value from the PRNG. The code below demonstrates setting the seed once, and then displaying two random values between 1 and 10:
org 100h
include emu8086.inc
start:
call srandsystime ; Seed PRNG with system time, call once only
call rand ; Get a random number in AX
call rand2num1to10 ; Convert AX to num between 1 and 10
call PRINT_NUM_UNS ; Print value in AX as unsigned
PRINT ", " ; Print delimiter between numbers
call rand ; Get another random number in AX
call rand2num1to10 ; Convert AX to num between 1 and 10
call PRINT_NUM_UNS ; Print value in AX as unsigned
ret
; Return number between 1 and 10
;
; Inputs: AX = value to convert
; Return: (AX) value between 1 and 10
rand2num1to10:
push dx
push bx
xor dx,dx ; Compute randval(DX) mod 10 to get num
mov bx,10 ; between 0 and 9
div bx
inc dx ; DX = modulo from division
; Add 1 to give us # between 1 and 10 (not 0 to 9)
mov ax,dx
pop bx
pop dx
ret
; Set LCG PRNG seed to system timer ticks
;
; Inputs: AX = seed
; Modifies: AX
; Return: nothing
srandsystime:
push cx
push dx
xor ax, ax ; Int 1Ah/AH=0 to get system timer in CX:DX
int 1ah
mov [seed], dx ; seed = 16-bit value from DX
pop dx
pop cx
ret
; Updates seed for next iteration
; seed = (multiplier * seed + increment) mod 65536
; multiplier = 25173, increment = 13849
;
; Inputs: none
; Return: (AX) random value
rand:
push dx
mov ax, 25173 ; LCG Multiplier
mul word ptr [seed] ; DX:AX = LCG multiplier * seed
add ax, 13849 ; Add LCG increment value
mov [seed], ax ; Update seed
; AX = (multiplier * seed + increment) mod 65536
pop dx
ret
seed dw 11 ; Default initial seed of 11
DEFINE_PRINT_NUM_UNS; Macro from include file to make PRINT_NUM_UNS usable
END
Footnotes:
-
1To get a random number in the range
lowertoupper(inclusive) you can use this general formula:rndvalue = (rand() % (upper-lower+1)) + lower;
-
Deficiency: converting the random value from the PRNG to a number between 1 and 10 still suffers from modulo bias.
-
I use Watcom's register calling convention (Page 12 for a description) when developing 16-bit assembly routines in general. That can be tailored to one's own needs.
-
This particular LCG PRNG has a period of about 65536 before the pattern repeats. This should be enough for most simple tasks.
A standard PC system is configured to have the PIT channel 0 fire 18.2 times per second. Each time it fires, an interrupt occurs, the BIOS counts how many times this happened since the system booted and stores this number in the BIOS data area at address 0040:006c. You can use this value as a “random” seed value for a PRNG for your program:
mov ax,0040h
mov es,ax ; load segment for BIOS data area
mov ax,es:006ch ; load number of IRQ8 since boot into ax
Since this value changes so often, it should appear to be random. I recommend you to shuffle it around a little so it doesn't increment with every call. (i.e. seed a PRNG and run it a few iterations).
I am not sure if Emu8086 emulates this correctly, but on a PC it should work.