Pic Micro, Arduino, Atmel, Microchip, Freescale, Texas Instrument, ecc. Strumenti di sviluppo, firmware e progetti.
#7981
Era un pò che questa cosa mi frullava in testa... ovvero fare una versione della scheda Z80-MBC2 usando una CPU V20.
In particolare ho usato la versione full static CMOS della V20, ovvero un uPD70108H, cosa che mi porterà importanti semplificazioni.

20190416_173956.jpg


Ho così realizzato un primo schema di prova e montato il tutto su un paio di breadboard:

20200126_105620b.jpg


Per facilitarmi le cosa ho utilizzato una scheda ARMando che simulerà tutto l'I/O necessario.
La versione finale probabilmente userà un Atmel32, in modo da avere tutti componenti THP.

Sarà un lungo viaggio dagli esiti incerti...
#7996
Ho iniziato i primi "esperimenti" con la CPU V20.
Essendo una versione "full static" posso eseguire singoli impulsi di clock ed usare i GPIO della scheda ARMando come un Logic Analyzer.

Nella foto ho forzato una istruzione di HALT (0xF4) sul bus dati facendo entrare la CPU V20 nella stato di HALT evidenziato dall'accensione del led blu:

20200203_185726b.jpg


Codice: Seleziona tuttoV20 on breadboard - A090120
IOS - I/O Subsystem (STM32F030R8) - S010220


 * RESET Done *
i = 0 HLDAK = 0
ASTB = 0 IOM_ = 1 RD_ = 1 WR_ = 1
A4 = 1 A3 = 0 A2 = 0 A1 = 0 A0 = 1
D7 = 1 D6 = 1 D5 = 1 D4 = 1 D3 = 0 D2 = 0 D1 = 0 D0 = 1

i = 1 HLDAK = 0
ASTB = 0 IOM_ = 1 RD_ = 1 WR_ = 1
A4 = 1 A3 = 0 A2 = 0 A1 = 0 A0 = 1
D7 = 1 D6 = 1 D5 = 1 D4 = 1 D3 = 0 D2 = 0 D1 = 0 D0 = 1

i = 2 HLDAK = 0
ASTB = 0 IOM_ = 1 RD_ = 1 WR_ = 1
A4 = 1 A3 = 0 A2 = 0 A1 = 0 A0 = 1
D7 = 1 D6 = 1 D5 = 1 D4 = 1 D3 = 0 D2 = 0 D1 = 0 D0 = 1

i = 3 HLDAK = 0
ASTB = 0 IOM_ = 1 RD_ = 1 WR_ = 1
A4 = 1 A3 = 0 A2 = 0 A1 = 0 A0 = 1
D7 = 1 D6 = 1 D5 = 1 D4 = 1 D3 = 0 D2 = 0 D1 = 0 D0 = 1

i = 4 HLDAK = 0
ASTB = 0 IOM_ = 1 RD_ = 1 WR_ = 1
A4 = 1 A3 = 0 A2 = 0 A1 = 0 A0 = 1
D7 = 1 D6 = 1 D5 = 1 D4 = 1 D3 = 0 D2 = 0 D1 = 0 D0 = 1

i = 5 HLDAK = 0
ASTB = 0 IOM_ = 1 RD_ = 1 WR_ = 1
A4 = 1 A3 = 0 A2 = 0 A1 = 0 A0 = 1
D7 = 1 D6 = 1 D5 = 1 D4 = 1 D3 = 0 D2 = 0 D1 = 0 D0 = 1

i = 6 HLDAK = 0
ASTB = 0 IOM_ = 1 RD_ = 1 WR_ = 1
A4 = 1 A3 = 0 A2 = 0 A1 = 0 A0 = 1
D7 = 1 D6 = 1 D5 = 1 D4 = 1 D3 = 0 D2 = 0 D1 = 0 D0 = 1

i = 7 HLDAK = 0
ASTB = 0 IOM_ = 1 RD_ = 1 WR_ = 1
A4 = 1 A3 = 0 A2 = 0 A1 = 0 A0 = 1
D7 = 1 D6 = 1 D5 = 1 D4 = 1 D3 = 0 D2 = 0 D1 = 0 D0 = 1

i = 8 HLDAK = 0
ASTB = 1 IOM_ = 0 RD_ = 1 WR_ = 1
A4 = 1 A3 = 0 A2 = 0 A1 = 0 A0 = 0
D7 = 1 D6 = 1 D5 = 1 D4 = 1 D3 = 0 D2 = 0 D1 = 0 D0 = 0

i = 9 HLDAK = 0
ASTB = 0 IOM_ = 0 RD_ = 0 WR_ = 1
A4 = 1 A3 = 0 A2 = 0 A1 = 0 A0 = 0
D7 = 1 D6 = 1 D5 = 1 D4 = 1 D3 = 0 D2 = 0 D1 = 0 D0 = 0


Il prossimo passo sarà predisporre una la sequenza di boot per caricare ed eseguire un file binario da microSD...
#8006
Sono riuscito a caricare in RAM e far eseguire un brevissimo programma di test di sole tre istruzioni assembler x86. :D
Il clock è in modalità "single pulse", per cui è molto lento (ma così mi serve in questa fase).
Il led bianco segnala operazioni di I/O (come quella dell'istruzione IN), il led blu segnala la CPU in modalità HALT.

Il codice macchina viene prima caricato in RAM , poi la CPU è forzata nello stato di HALT. Successivamente è eseguito un reset della CPU che esegue il codice in RAM (ricordo che al reset viene eseguita la prima istruzione all'indirizzo FFFF:0000, nel video l'indirizzo della prima istruzione è sbagliato... :shock: ):

#8033
Finalmente il primo programma eseguito dalla CPU V20 con il clock in "free running" a 8MHz e caricato dalla microSD!... :D

Screenshot_20200219_192837.png


Ho utilizzato NASM come assembler 8086/8088. Di seguito il sorgente:

Codice: Seleziona tutto;
; Test HelloWord - HW ref: A090120 (V20 on breadboard)
;
; REQUIRED: IOS S010220 DEVEL_16 (STM32F030R8)
;
; Assemble with "nasm -f bin  filename.asm -o filename.bin"
;
    [map mapFile.txt]   ; Set output map file
    CPU     8086        ; Set 8086/8088 opcodes only
    BITS    16          ; Set default 16 bit

eos         equ     0x00    ; End of string
   
; IOS equates
EXC_WR_OPCD equ    0x00      ; Address of the EXECUTE WRITE OPCODE write port
EXC_RD_OPCD equ    0x00      ; Address of the EXECUTE READ OPCODE read port
STO_OPCD    equ    0x01      ; Address of the STORE OPCODE write port
SERIAL_RX   equ    0x01      ; Address of the SERIAL RX read port
SYSFLAGS    equ    0x02      ; Address of the SYSFLAGS read port
SERTX_OPC   equ    0x01      ; SERIAL TX opcode

    org  0
    ;
    ; Init
    ;
    mov     ax, cs          ; DS = SS = CS
    mov     ds, ax
    mov     ss, ax
    mov     sp, stack       ; Set the stack
    ;
    ; Print a message and halt
    ;
    mov     bx, msg
    call    puts
halt:
    hlt
    jmp     halt
   
; =========================================================================== ;
;
; Send a string to the serial line, DX contains the pointer to the string.
; NOTE: Only AL and BX are used
;
; =========================================================================== ;
puts:
    mov     al, [bx]        ; AL = current char to print
    cmp     al, eos         ; End of string reached?
    jz      puts_end        ; Yes, jump
    mov     al, SERTX_OPC   ; AL = SERIAL TX opcode
    out     STO_OPCD, al    ; Write the opcode
    mov     al, [bx]        ; AL = current char to print
    out     EXC_WR_OPCD, al ; Print AL
    inc     bx              ; Increment character pointer
    jmp     puts            ; Transmit next character
   
puts_end:
    ret
   
   
msg     db  'Hello, World!', 0x0d, 0x0a, eos    ; 0x00 is the message terminator
        times   0x100   db  0;
stack:


Ora altri test, ma si può iniziare a pensare alla versione finale della scheda...
Bios ringraziano
#8037
Altro piccolo passo avanti...
Usare alla lunga la microSD per testare un eseguibile diventa fastidioso, considerando che ogni volta bisogna estrarla a inserirla in un adattatore USB e copiare il nuovo file manualmente. Così ho deciso di fare il "porting" dell'utility iLOAD che avevo sviluppato in precedenza per la scheda Z80-MBC2. Si tratta di un semplice loader dalla porta seriale che accetta in ingresso un file in formato Intel-HEX, lo carica in RAM (con i dovuti controlli) e lo esegue.
Così sono partito dal sorgente scritto in assembler Z80 e l'ho "tradotto" a mano riga per riga in assembler 8088:

Screenshot_20200222_110851.png

Nella foto si vede il precedente test "hello world" inviato in formato Intel-Hex tramite iLOAD, che terminato il caricamento in RAM provvede ad eseguirlo.
Con iLOAD è ora possibile avere una "toolchain" automatica che con un solo comando assembla, carica ed esegue sul target!
Ora questo piccolo sistema è diventato realmente usabile...
#8088
Per provare la modalità 8080 della CPU V20 ho fatto il "porting" dell'Altair Basic (scritto in codice macchina 8080).
Inoltre ho realizzato una nuova versione di iLoad, che ho chiamato iLoad-80, per caricare eseguibili in codice 8080.
Dopo il caricamento iLoad-80 attiva la modalità 8080 della CPU V20 e poi esegue il codice caricato.

Nel video seguente una demo con l'Altair Basic:

Bios ringraziano
#8096
Ciao just 4fun,

ho visto il tuo messaggio in questo e anche in un altro forum, il tutto semrba interessante, ma, tuttavia, forse, e' presentato un po' come una dimostrazione di capacita'.

Sarebbero casomai anche interessanti alcuni dettagli riguardo lo scopo finale di tutto questo, e, se puo trovare utilita' per gli utenti del forum.

Se sei appassionato di z80 immagino saprai che ci sono versioni piu moderne strapiene di periferiche e flash interna:
https://www.mouser.com/catalog/supplier/library/ZilogeZ80F91.pdf

Per il resto, complimenti, pare un gran lavoro.
Bios ringraziano
Indicatore di stato batteria

Il rum era sicuramete buono! :D :D :D Però l'id[…]

[CUT] Le varie sedi, Milano, Bolzano, etc sono t[…]

Virus & democrazie II

@schottky , argomenta pure. :D

KS0107B https://www.waveshare.com/datasheet/LCD_en[…]

Visita il nostro canale telegram