0
\$\begingroup\$

In case of timing diagrams of 8085, what I saw is that, always Opcode Fetch, Memory Read/Write, IO Read/Write is shown but execution is never shown. Is it because the execution time is too less compared to others? Thanks in advance.

For example, In case of MVI A, 55H they show 4 T state for Opcode Fetch, 3 for M/m Read that's it. No T state for execution is ever shown.

Reference: Ramesh Gaonkar 8085 Microprocessor Book.

\$\endgroup\$
3
  • \$\begingroup\$ Does the 8085 have "ADD HL,BC"? What timings does the book list for that? \$\endgroup\$
    – supercat
    Jul 8, 2013 at 16:35
  • \$\begingroup\$ No, 8085 does not have such instruction. It has ADD A,M where M is the memory location pointed by HL register pair. For that also, it has similar timing diagram. \$\endgroup\$
    – Enthusiast
    Jul 8, 2013 at 16:43
  • \$\begingroup\$ How about "DAD B", which is the Intel name for the 09 opcode (the same one as Z80 assembly language instruction "ADD HL,BC"). \$\endgroup\$
    – supercat
    Jul 8, 2013 at 18:53

2 Answers 2

2
\$\begingroup\$

In the history of microprocessors the start was with very slow processors and very fast memory (a 6502 did a fetch, then execute, and in the execute phase the memory was free to be used for other purpsoes, like DMA or video generation). The Z80 had similar 'idle' period in the instruction execute that could be sued for DRAM refresh.

With the generation of the 8085 the controller could just about finish an instruction before the memory was ready for the next memory cycle, hence the execution time does not show in the timing graphs.

After this the situation got more confused. On the one hand the controllers got faster, so the bus timing became totally dominated by memory access. But on the other hand controllers started to implement much more complex instructions like multiply and divide, which do show up in the timing. And the addition of caches and pipelining make everying even more confused.

\$\endgroup\$
1
  • 1
    \$\begingroup\$ On the 6502, there was a 1:1 correspondence between memory accesses and CPU cycles; every CPU cycle which wasn't a write would read a byte from some address, whether or not the processor would have any use for the value read. In some cases, the read would be from an address that may or may not be correct; if the address was correct, the read value would be used, but if it was incorrect the processor would ignore the value and read the correct value on the next cycle. \$\endgroup\$
    – supercat
    Jul 8, 2013 at 20:12
0
\$\begingroup\$

Probably such timing is not shown because it is irrelevant to using the processor. All you need to know is that the result of one instruction is available as input to the next, except when it is stated to the contrary. Where exactly in the cycle the operation takes place or finishes is irrelevant because there is nothing you can do about it whether it finishes halfway thru or just before the end. At the maximum instruction clock, the most complicated operation probably finishes just before the end of the instruction, with whatever margin is necessary to guarantee correct operation over all the operating conditions.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

Not the answer you're looking for? Browse other questions tagged or ask your own question.