Digital Electronics and Microprocessor

Digital Electronics and Microprocessor Question and Answers

( Suggestion :  keep refreshing the page for updated content & Search Questions Using Find )

Q2. Design a synchronous modulo-5 counter using JK-flip flop which counts through the stages given 0 to 1 to 5 to 7 to 6 to 0 and repeats.

Ans – To design a synchronous modulo-5 counter using JK flip-flops that counts through the specified sequence (0, 1, 5, 7, 6, 0) and repeats, we need to create a state transition table and then implement the JK flip-flop circuit accordingly. Let’s use a 3-bit counter to represent the states.

Here’s the state transition table:

In the table, the columns represent the current state, the next state, and the JK inputs for the flip-flops. The next state values are in binary, and JK inputs are given based on the desired sequence.

Now, let’s design the JK flip-flop circuit. We’ll use three JK flip-flops (FF1, FF2, and FF3) to represent the three bits of the counter.

• Connect the J and K inputs of FF1, FF2, and FF3 according to the JK input values in the table.
• Connect the clock (C) input of all flip-flops together.
• Use the Q outputs of FF1, FF2, and FF3 as the three output bits (Q2, Q1, Q0) of the counter.

Here’s a textual representation of the circuit:

Connect the JK inputs and clock as follows:

• JK inputs for FF1: J1 = 0, K1 = 1
• JK inputs for FF2: J2 = 1, K2 = 0
• JK inputs for FF3: J3 = 1, K3 = 1
• Connect the clock (CLK) input to the clock signal.

Q3. Use a stack map to show the effect of each of the following instructions on the stack pointer and on the contents of the stack. Name the registers that are going to reside in Stack

Ans-

A stack is often used to store temporary data and manage subroutine calls. The stack pointer (SP) is a register that points to the top of the stack. Let’s use a hypothetical assembly-like language to illustrate the effects of certain instructions on the stack. We’ll assume there’s a stack map that shows the state of the stack before and after each instruction.

Let’s use the following conventions:

• SP: Stack Pointer
• R1, R2, R3: General-purpose registers
• [ ]: Value at the memory location

Initial Stack: [ ] (Empty Stack)

1. PUSH R1
   • Before: [ ]
   • After: [R1]
   • SP: SP – 1
2. PUSH R2
   • Before: [R1]
   • After: [R1, R2]
   • SP: SP – 1
3. POP R3
   • Before: [R1, R2]
   • After: [R1]
   • R3: R2 (value popped from the stack)
   • SP: SP + 1
4. PUSH R3
   • Before: [R1]
   • After: [R1, R3]
   • SP: SP – 1
5. POP R2
   • Before: [R1, R3]
   • After: [R1]
   • R2: R3 (value popped from the stack)
   • SP: SP + 1

Q4. Construct the binary code for the instruction MOV CX, [BX]

Ans- The x86 assembly language instruction “MOV CX, [BX]” can be represented in binary code. Here’s the breakdown of the binary encoding:

1. Opcode for MOV instruction:
   • The opcode for the MOV instruction is typically represented by the binary code 100010.
2. ModR/M byte:
   • The ModR/M byte specifies the operand addressing mode and the registers involved in the instruction. For the MOV instruction with a memory operand, the ModR/M byte is constructed as follows:
     • Mod field: 00 (indicating a memory operand addressed by only the base register, BX).
     • Reg/Opcode field: 01 (indicating CX as the destination register).
     • R/M field: 011 (indicating BX as the base register).

   So, the ModR/M byte becomes 00011011 in binary.

3. Displacement (Optional):
   • Since there is no displacement in this case (no immediate value or offset), this part is all zeros.

Putting it all together, the binary representation of the “MOV CX, [BX]” instruction is as follows:
10001000 00011011 00000000

Q5. Write an Assembly Language Program to search for a character in a given string and calculate the number of occurrences of the character in the given string (new)

Ans- x86 assembly language program using NASM syntax that searches for a character in a given string and calculates the number of occurrences of that character:

section .data
input_string db ‘This is a sample string.’, 0
search_char db ‘s’ ; Change this character to the one you want to search for
newline db 10 ; Newline character for printing

section .text
global _start

_start:
; Set registers
mov ecx, 0 ; Counter for the number of occurrences
mov esi, input_string ; Source index for the input string
mov al, search_char ; Character to search for

search_loop:
; Compare the current character with the search character
cmp byte [esi], al
je found_char

; If end of string is reached, exit the loop
cmp byte [esi], 0
je end_program

; Move to the next character in the string
inc esi
jmp search_loop

found_char:
; Increment the counter for the number of occurrences
inc ecx

; Move to the next character in the string
inc esi
jmp search_loop

end_program:
; Display the result
mov eax, 4 ; syscall: sys_write
mov ebx, 1 ; file descriptor: STDOUT
mov ecx, ecx ; number of occurrences
mov edx, 4 ; length of the message
mov esi, ecx ; pointer to the message
int 0x80 ; call kernel

; Exit the program
mov eax, 1 ; syscall: sys_exit
xor ebx, ebx ; status: 0
int 0x80 ; call kernel

Q6.Write an assembly language program to find the LCM of two numbers

Ans- Here’s a simple example of an x86 assembly language program to find the Least Common Multiple (LCM) of two numbers using the Euclidean algorithm. This example assumes that the input numbers are stored in memory at addresses num1 and num2:

section .data
num1 dd 12 ; Change these values as needed
num2 dd 18 ; Change these values as needed
result dd 0

section .text
global _start

_start:
; Load the numbers into registers
mov eax, [num1]
mov ebx, [num2]

; Calculate GCD using Euclidean algorithm
call find_gcd

; Calculate LCM using the formula: LCM(a, b) = (a * b) / GCD(a, b)
mov eax, [num1]
mul dword [num2]
div dword [result]

; The result is now in eax

; Exit the program
mov eax, 1 ; syscall number for exit
xor ebx, ebx ; exit code 0
int 0x80 ; make syscall

find_gcd:
; Euclidean algorithm to find GCD
; Inputs: eax = num1, ebx = num2
; Outputs: result = GCD(num1, num2)

cmp ebx, 0
je .done

; Swap if necessary
mov edx, eax
mov eax, ebx
mov ebx, edx

; Calculate remainder
xor edx, edx
div ebx

; Save remainder for the next iteration
mov [result], edx

; Recursively call find_gcd
call find_gcd

.done:
ret

Q7.a) Write the Control Word Register (CWR) format of a Programmable Peripheral device (8255A) interfacing with 8086 to work as an I/O port to initialize port A as input, port B as output, Port C upper as input and Port C lower as output. Use Mode 1 for group A and Mode 0 for group B. Address of CWR-43h. Assume CS’, WR’ of 8255A are both logical 0.

Q8. A) Predict the state of the six 8086 conditional flags after each of the following instructions or group of instructions executes. Use the register contents shown in figure below. Assume that all flags are reset before the instructions execute. a. MOV AL, AH b. ADD BL,CL
B) Describe the operation and results of each of the following instructions, given the register content shown in figure above. Include in your answer the physical address or register that each instruction will get its operands from and the physical address or register that each instruction will put the result in. a. ROL AX,CL b. JMP BX c. ADD AX, [BX][SI]

Ans- A) a. MOV AL, AH: Copies the contents of AH to AL. No flags are affected. b. ADD BL, CL: Adds the contents of CL to BL. Flags affected: CF (Carry Flag), PF (Parity Flag), AF (Auxiliary Flag), ZF (Zero Flag), SF (Sign Flag), OF (Overflow Flag).

B) a. ROL AX, CL: Rotates the bits in AX left through the carry flag, the number of times specified in CL. Flags affected: CF, OF, SF, ZF, PF. b. JMP BX: Unconditional jump to the address specified in BX. c. ADD AX, [BX][SI]: Adds the word at the address formed by adding BX and SI to the contents of AX. Flags affected: CF, OF, SF, ZF, PF.

For More Updates Join Our Channels :