Telas do speccy no MSX – parte 2

tbzscmcb-2_abertura

Na parte anterior cuidou das diferenças no vídeo entre os dois computadores, ou seja, o modo como são dispostos os padrões e atributos que compõe a imagem na tela, assim como os tipos de atributos disponíveis, as cores geradas pelos respectivos circuitos de vídeo e também o “truque” usado para simular a relação de luminância das cores do ZX Spectrum no MSX.

Agora é a vez do arquivo que armazena a tela de vídeo do speccy, um programa para visualizá-lo em MSX-BASIC e, o mais importante de todos, uma rotina em assembly para carregar arquivos do disco para a memória.

Outros modos de vídeo

Antes de seguir adiante é bom definir um escopo, ou seja, o objetivo aqui é visualizar no MSX as imagens no modo de vídeo padrão do ZX Spectrum, 256×192 com 16 cores e com apenas duas cores por bloco de 8×8, ou seja, aquilo que é produzido sem muito esforço pela ULA¹ — o integrado que cuida, dentre outras tarefas, da geração o sinal de vídeo no computador.

É claro que este não é o único modo de vídeo disponível nos speccy, há diversos outros implementados em hardware (as versões da Timex e alguns dos clones produzidos na URSS/Rússia) e software. Alguns até podem ser visualizados em um MSX e outros somente a partir de um MSX2 mas, por enquanto, vamos voltar ao formato padrão, o “Standard 6912”.

(¹) Aqui não significa unidade lógica e aritmética mas sim uncommitted logic array, o termo britânico para gate array. E que consiste no processo de produzir um circuito integrado específico para uma determinada finalidade contendo um conjunto determinado de portas lógicas.

Arquivos SCR

Eles quase sempre contém a extensão “SCR”², tem exatos d6.912 bytes de tamanho e correspondem a um snapshot da memória de vídeo (tabelas de padrões e de atributos). O arquivo não possui cabeçalho ou separador e pode ser criado em Sinclair BASIC usando:

SAVE "«nome do arquivo»" CODE 16384,6912

O que este comando faz é criar um arquivo em disco (fita cassete, microdrive etc) com o conteúdo dos 6.912 bytes da RAM a partir do endereço de memória 16.384 (0x4000) — o início da memória de vídeo.

Visualizando os arquivos em MSX-BASIC

Assim, juntando a informação sobre a estrutura do arquivo e sobre como os dados estão organizados, é possível prototipar algo em MSX-BASIC e verificar se tudo está correto:

A parte curiosa do programa são os quatro laços FOR…NEXT simulando a organização da tabela de padrões do ZX Spectrum e evitando o uso de multiplicações, algo que não é o forte do Z80. 🙂

A linha 185 pode até ser alterada para salvar o conteúdo da VRAM em disco, algo como:

185 BSAVE "CHASEHQ.SC2",&H0,&H3FFF,S:K$=INPUT$(1)

Mas por que não deixei assim logo de início?

Simples, acontece que meu objetivo é visualizá-las e não convertê-las. Acontece que com a conversão o arquivo com a imagem passa de 6.912 bytes para 14.343 bytes já que bastante informação acaba sendo replicada. Alguma compressão de dados poderia ser implementada mas acabaria ficando próximo ao SCR original e para fazer tanto um conversor como também um visualizador fica mais simples fazer somente este último.

Ah claro, o programa em MSX-BASIC demora cerca de quatro minutos para mostrar a imagem na tela, em assembly a coisa ficará bem mais rápida mas antes de fazer estar parte do programa é importante saber transferir o conteúdo do arquivo SCR do disco para um lugar onde o Z80 consiga enxergá-lo, ou seja, a RAM.

(²) Claro, não confundir o arquivo “SCR” do speccy com o formato para arquivos de telas de mesma extensão utilizado no Graphos III, editor gráfico para MSX desenvolvido por  Renato Degiovani em 1987.

Carregando um arquivo em assembly

Manipular arquivos em disco significa interagir com as rotinas do sistema operacional do MSX, no caso o MSX-DOS. E ao contrário do que aparenta ele não está armazenado em disco — no caso os arquivos “MSXDOS.SYS” e “COMMAND.COM” — e sim gravado na ROM da interface — onde geralmente chamado de BDOS.

Acessando as rotinas da BDOS

Sendo compatível com a versão 2.2 do CP/M o MSX-DOS implementa (quase) todas as chamadas de rotinas deste e, claro, a mesma forma de chamá-las:

ld c,«rotina da BDOS»
call BDOS

Dependendo da rotina a ser chamada os registradores DE ou HL podem ser utilizados para passagem de parâmetros e aquilo que chamei de “BDOS” pode ser o endereço 0xF37D (MSX-BASIC), ou 0x0005 (MSX-DOS), dependendo do ambiente a ser executado.

File Control Block

No caso específico das rotinas que fazem acesso a arquivos usa-se uma estrutura de dados chamada File Control Block (FCB) para a passagem dos diversos parâmetros necessários (nome do arquivo, extensão, drive etc).

Deslocamento Tamanho Campo
0x00 1 Drive (0=Atual, 1=A, 2=B etc)
0x01 8 Nome do arquivo
0x09 3 Extensão do arquivo
0x0c 2 Número de bloco corrente
0x0e 2 Tamanho do registro (em bytes)
0x10 4 Tamanho do arquivo (em bytes)
0x14 2 Data
0x16 2 Hora
0x18 8 Reservado
0x20 1 Registro Corrente
0x21 4 Número do registro de acesso aleatório

Fonte — “Fudeba Assembler: Manual e Referência da Arquitetura MSX

Fazendo uma analogia com linguagens de programação formais o FCB funcionaria como um file handler pois é referência para abertura, leitura/gravação dos dados e fechamento do arquivo — mas como também é usado para apagar, renomear, ler o diretório etc sua função acaba sendo mais ampla que um simples file handler.

Lendo um arquivo

Para ler um arquivo do disco em assembly usando os comandos da BDOS são feitos os seguintes passos:

  1. Colocar o nome do arquivo na FCB.
  2. Indicar o endereço da RAM onde colocar o bloco lido.
  3. Abrir o arquivo — chamando a rotina³ 0x0F.
  4. Recuperar o tamanho do arquivo — chamando a rotina 0x23.
  5. Posicionar o ponteiro do arquivo para seu início.
  6. Definir tamanho do bloco a ser lido (tamanho do registro).
  7. Transferir o conteúdo para a RAM — chamando a rotina 0x27 e
  8. Fechar o arquivo — chamando a rotina 0x10.

Claro que entre cada chamada de rotina é necessário executar a respectiva verificação sobre o resultado da execução e desviar a execução para a rotina de tratamento de erros. — opa, você faz tratamento dos erros, não faz? 🙂

Programa para leitura de arquivos

Ele foi feito para ser (quase) genérico e o que ele faz é transferir de uma vez só o conteúdo de qualquer arquivo, bastando informar corretamente nome e tamanho do arquivo que se deseja carregar.

Monte usando:

$ pasmo -d -v loadfile.asm loadfile.bin

Para testá-lo:

Claro, ele foi pensado para arquivos pequenos e possam ser carregados integralmente nos ~20KiB de memória RAM disponíveis no BASIC — portanto, cuidado com as experiências.

(³) As rotinas estão identificadas por seus números, não existe uma nomenclatura oficial — seja por parte da Digital Research, ASCII, Microsoft etc — e cada autor utiliza a sua. Aqui estou usando os nomes criados pelo Felipe Bergo no Capítulo 6 do “Fudeba Assembler: Manual e Referência da Arquitetura MSX”.

Finalizando esta parte

Como decidi que meu programa de visualização funcionará no MSX-DOS eu precisarei saber como recuperar os argumentos passados na linha de comando para pegar o nome do arquivo e eventuais parâmetros. Mas isto ficará para a próxima parte.

Ah sim, prometo não usar mais a tela de abertura do Chase H.Q. nos exemplos!  🙂

Anúncios

Um comentário sobre “Telas do speccy no MSX – parte 2

  1. Pingback: Telas do speccy no MSX – parte 3 | giovannireisnunes

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s