Os padrões de ladrilhos de Truchet para o ZX81

Depois de fazer o programa de apresentação dos ladrilhos de Truchet para MSX,  cuja origem, história e processo descrevi em outro artigo publicado neste blog, fiquei pensando sobre um programa semelhante no ZX81, mesmo com as suas limitações gráficas.

No MSX, cada ladrilho (tile) equivale a um caractere de 8x8 pixels, para uma tela de resolução de 256x192. No ZX81, utilizar ladrilhos 8x8 seria inviável, tendo em vista que, pela baixa resolução do micro (64x48), a tela comportaria a impressão de poucos ladrilhos, impossibilitando o efeito visual que justamente se dá pelo conjunto dos diversos ladrilhos organizados em padrões.

Pensei então em ladrilhos em uma grade de 4x4 "pixels", formados por 4 caracteres gráficos do ZX81. Mãos à obra, iniciei por desenhar os ladrilhos e encontrar os códigos dos caracteres gráficos correspondentes. Na mão mesmo:

Em seguida, escrevi um programinha em BASIC no TK85 para testar e dispor os ladrilhos na tela. Ali pude constatar que valia a pena seguir em frente.

Conforme contei no artigo sobre os ladrilhos no MSX, havia feito um programa em BASIC para entrar como os dados dos padrões em linhas DATA. A ideia agora era reaproveitar os dados do MSX e exportá-los para o programa assembly do ZX81 que, já estava decidido, seria montado no Pasmo. 

Com este propósito, no MSX, utilizei duas ferramentas simples.

Primeiro, utilizei um programa para jogar os dados das linhas DATA com os padrões de Truchet para a memória do MSX, que eu já havia utilizado na versão para aquela máquina. Fiz algumas adaptações dos dados para o ZX81, porque o MSX utiliza o código de caracteres ASCII e, na época do desenvolvimento do ZX81, a Sinclair Research achou por bem utilizar seu próprios códigos de caracteres. Então, ao mover os dados para a memória, fiz um filtro de conversão dos caracteres ASCII que nomeiam os padrões de Truchet (A-Z, 1-6), para os respectivos códigos do ZX81 (de caracteres invertidos, mais especificamente). Tive que improvisar com o padrão nomeado por Truchet de "&", caractere que simplesmente não existe no ZX81, colocando um "+" no seu lugar. No mais, converti também o código dos caracteres redefinidos no MSX, nºs 192, 193, 194 e 195, que não fariam sentido no ZX81, para 0, 1, 2 e 3. 

Feito isto, utilizei outro programa, que eu eu já possuía, para ler os bytes da memória e gerar linhas de dados (DEFB) num arquivo ASCII. Este programa eu havia utilizado para exportar a tabela com caracteres katakana e outros caracteres redefinidos quando escrevi a versão do programa Matrix - Raining Code para MSX-DOS, o que fiz utilizando o excelente Gen80, da Hightech.  

A partir daí, poderia passar a trabalhar no programa assembly para o ZX81, uma vez que a estrutura dos dados já havia sido testada na versão para MSX.

Programa no MSX-BASIC para geração de linhas DEFB num arquivo ASCII

Em seguida, exportei o arquivo ASCII resultante, através de um comando do emulador openMSX, para uma pasta, a fim de que depois pudesse importá-lo no editor de texto que utilizo nos projetos para ZX81, o glorioso nano. É isso mesmo, vivo no terminal do Linux Debian de um Raspberry Pi dedicado à retroprogramação. Sem firulas de interface gráfica: salvo o programa do editor, executo um shell script para, numa tacada, montar o programa no Pasmo, gerar o arquivo .p (com o appmake) e já mover esse arquivo para a pasta do emulador de ZX81, o qual deixo ativo em outro terminal TTY para que eu possa testar o programa recém montado. É um fluxo de trabalho que funciona muito bem.

Sobre o programa assembly, ainda que o MSX e o ZX81 tenham a mesma CPU, optei por reescrever o programa para o ZX81 do zero. As peculiaridades do hardware de vídeo do MSX (com processador de vídeo dedicado e memória de vídeo externa) versus as peculiaridades da estrutura da memória de vídeo do ZX81 (D_FILE), fizeram-me pensar que escreveria um código melhor se não aproveitasse o anterior. 

Mas de qualquer forma, implementei os mesmos recursos da versão MSX: apresentação dos padrões em tela cheia, com passagem automática após alguns segundos para o próximo padrão, passagem manual ao próximo padrão (para quem tem pressa neste mundo) pressionando SPACE e, ainda, opção de ativar ou desativar as legendas que nomeiam o padrões, pressionando NEW LINE. Volta-se ao BASIC pressionando "Q". Fiz também uma moldura com caracteres "cinzas", para que os desenhos dos padrões não emendassem com a borda branca da tela do ZX81, o que altera um tanto o efeito dos padrões. O resultado se vê no vídeo abaixo que, de de minha parte, considero bastante satisfatório. Estrelando, o TK85 da Microdigital:

Depois que gravei esse vídeo, ainda acertei uns pequenos detalhes. O arquivo do programa em formato .p está disponível no link abaixo.

Download do arquivo .p

Os padrões de ladrilhos de Truchet para MSX

Mais uma vez, assistindo ao excelente canal do Youtube 8-Bit Show and Tell, tomei gosto pela história ali contada e resolvi replicar o programa, feito pelo Robin para o Commodore 64, no seu primo contemporâneo, o MSX.

Não é a primeira vez que isso acontece. Também me empolguei quando vi o vídeo sobre o "Pitfall Pamphlet", no mesmo canal, e fiz uma versão para MSX, que publiquei aqui uns anos atrás.

Desta vez, o episódio era sobre os "Ladrilhos de Truchet em PETSCII" (Truchet's tiles in PETSCII) que, resumidamente, conta a história do estudo com padrões de ladrilhos feito pelo padre dominicano Sébastien Truchet, em 1704. Em seguida, o apresentador mostra um programa feito por ele que imprime os padrões de Truchet na tela do C64.

Ao trabalho, comecei por obter a publicação original de Truchet, que foi feita no Memoires de l'Academie Royale des Sciences, de 1704, que era uma espécie de um anuário científico com diversos artigos sobre matemática, física, etc. A propósito, acho fantástico que possamos ter acesso a esses tipos de documentos históricos pela internet.

O estudo de Truchet, chamado Memoire Sur Les Combinaisons, inclui 30 padrões diferentes. Mostro aqui os primeiros 12, por brevidade: 

Primeiros doze padrões do estudo de Truchet.

Como se pode observar, os padrões são elaborados a partir de um único ladrilho quadrado, dividido diagonalmente, metade preto, metade branco, sendo este ladrilho rotacionado nas quatro posições a seguir:

 

Ladrilhos, do original

 

 

O MSX não tem os caracteres necessários na sua tabela padrão, como é o caso do  Commodore 64 (PETSCII). Por isto, utilizando o meu editor de caracteres "Pixit", redefini os caracteres nºs 192,193,194 e 195 (escolhidos a esmo), para que correspondessem aos ladrilhos nas quatro posições originais. 

Detalhe da edição no Pixit.

Como bem observou o Robin no seu vídeo, se tentarmos dividir uma grade 8x8 numa diagonal, com uma "metade" de pixels acesos e a outra "metade" apagados, na realidade, o número de pixels acesos e apagados nunca será igual numa grade quadrada de dimensões pares: a própria linha diagonal que divide as metades deverá ser composta ou de pixels acesos, ou de pixels apagados. Optei por uma maior quantidade de pixels apagados (pretos), porque achei que ficaria mais próximos ao desenhos originais, que possuem linhas divisórias pretas entre os ladrilhos.

Como a definição dos 4 caracteres corresponde a apenas 32 bytes, anotei os hexadecimais (descritos na lateral esquerda da grade de edição), para depois passar os dados ao programa.

Em seguida, escrevi um programa no MSX BASIC, onde poderia entrar manualmente com os dados dos padrões (através de linhas data) e, ainda, testar a estrutura dos mesmos, visualmente, na tela. Fui então traduzindo, por análise visual, cada padrão para os dados correspondentes. O padrão "A", por exemplo, é uma matriz de 1 linha por 1 coluna, e o caractere utilizado, na minha convenção, é o 192. A linha data seria:

DATA 1,1,192 

O padrão "B", é composto de 2 linhas e 1 coluna, e os caracteres são 192 e 194:

DATA 2,1,192,194

O padrão "C", é composto de 2 linha e 2 colunas, e os caracteres são 192 e 194 na primeira linha, e 194 e 192 na segunda:

DATA 2,2

DATA 192,194

DATA 194,192 

E assim por diante. Dá para perceber que o estudo de Truchet vai se tornando mais complexo a cada padrão apresentado. 

Claro, é um bocado de dados digitados manualmente. Um dos padrões, sozinho é uma matriz de 12x12, ou seja, só ali são 144 bytes. Mas isso não é nada para quem viveu a experiência oitentista de digitar programas de revistas, cheios de linhas data maçantes e que, frequentemente, continham dados errados. Assim, imbuído da daquela paciência de artesão, que vê com prazer o resultado das minúcias de seu trabalho surgir aos poucos, dei sequência e logo concluí a empreitada.  

Acrescentei ainda, no início dos dados de cada padrão, a letra ou número que Truchet utilizou para nomeá-los. Achei que ficaria interessante mostrar a identificação original numa legenda abaixo do padrão. No final, ficou assim o resultado do programa BASIC na tela: 

 

Como se vê, a ideia do programa é, preencher a tela toda com um padrão, tenha ele a dimensão que tiver (1x1, 2x1, 4x4, 10x10). No BASIC, reduzi o tamanho da janela de impressão porque a intenção do programa ali era apenas servir de teste e porque o interpretador demorava um tanto para imprimir cada tela. Na verdade, durante os testes, por questão de agilidade, a janela era ainda menor do que aparece aí na imagem acima. Depois é que dei uma melhorada na estética. Entretanto, na versão definitiva, em assembly, a tela toda viria a ser utilizada, 32x24, na Screen 1. 

Encerrada esta etapa do BASIC, era hora de iniciar o programa em assembly. Comecei escrevendo no Mega Assembler o código que mostrasse na tela toda um padrão de 2 linhas por 3 colunas, com dados quaisquer (utilizei as letras ABC e DEF, só para testar o mecanismo).

Com o mecanismo básico funcionando a contento, utilizei o BASIC mais uma vez. Carreguei o programa dos ladrilhos em BASIC e apaguei toda a parte que imprimia os dados na tela, deixando apenas as linhas de dados. Então escrevi uma rotina para jogar os dados na memória RAM e, ao final, apresentar o endereço final dos mesmos. Escolhi como endereço inicial C000H (na realidade, depois alterei esse endereço para C200H):

Executado o programa, agora eu possuía o endereço inicial e o endereço final dos dados. Salvei-os com o comando BSAVE num arquivo de formato binário.

Em seguida, alterei o endereço inicial de montagem do programa em assembly para o byte imediatamente seguinte ao do final dos dados, de forma que poderia salvar tudo com BSAVE em um único binário, com o endereço inicial dos dados, o endereço final do executável e o respectivo endereço de execução.

Depois foi "só" uma questão de depuração do programa, otimização, ajustes e inclusão de alguns recursos, como a possibilidade de se incluir ou retirar as legendas nas telas apresentadas (teclando RETURN) e de se avançar manualmente a apresentação dos padrões (teclando ESPAÇO), já que se nenhuma tecla for pressionada, o programa vai exibindo automaticamente cada padrão por alguns segundos, como numa apresentação. ESC volta ao BASIC.

Acrescento ainda, como curiosidade, a rotina que impedia a repetição das teclas pressionadas, que estava funcionando normalmente no emulador, no Expert estava resultando em salto dos padrões que deveriam ser apresentados. Fiz a edição do ajuste necessário no Mega Assembler, no Expert. Pra se ver que emulação nunca é 100%.

E o resultado final é esse do vídeo abaixo, em toda a glória de uma TV de tubo.

Imagem do disco para download

 

 

 

 

 

Matrix - Raining Code para o TRS-Color

Tempos atrás, depois de fazer o Raining Code para o MSX, portei para o ZX81 e para o TRS-80, o que ocorreu com certa facilidade, porque todos utilizam o Z80 como processador e, assim, só precisava fazer as devidas adaptações para o hardware de vídeo.

Aí pensei: fazer esse programa para o TRS-Color seria muito legal, porque ele tem um modo de alta resolução (256x192), como o MSX, em duas cores (verde e preto). Além disso, até onde eu sei, ninguém havia feito ainda, ao menos em alta resolução. 

Só que minha falta de intimidade com o assembly 6809 foi, há dois anos atrás, uma barreira insuperável e acabei engavetando o projeto. Na época tentei portar o código, traduzindo as instruções e endereços do Z80 para o 6809. Minha abordagem do problema não ajudou, pelo contrário, apenas complicou.

Recentemente, resolvi retomar e cheguei à conclusão que a única maneira de avançar com o programa era retroceder. Assim, em vez de tentar portar o código do Z80 para o 6809, resolvi recomeçar do zero, de maneira que ia escrevendo o código aos poucos, ao tempo que ia aprendendo melhor o assembly do 6809. Depois de uma certa relutância inicial, meu cérebro finalmente sintonizou comunicação com o 6809 e a partir daí a programação fluiu. Tomei como lição que tentar traduzir a implementação diretamente do Z80 para o 6809 é um equívoco e que o melhor é focar no algoritmo, ou seja, partir de um nível de abstração mais elevado, para daí iniciar a nova implementação. Isso permite o uso mais adequado das peculiaridades de uma linguagem sem a interferência das técnicas de implementação da outra.

O processo

Comecei "importando" os caracteres alfanuméricos e katakana de uma ROM japonesa do MSX. Infelizmente não arrumei uma maneira de fazer isso diretamente, porque não há compatibilidade de arquivos entre o MSX e o TRS-Color, tampouco encontrei maneira de importar os dados via emulador. O jeito foi fazer à mão. Janela do openMSX de um lado, com o meu editor (não publicado) fornecendo as informações byte a byte dos caracteres, janela do Xroar do outro, anotando os dados em linhas data no Color Basic. Com muita paciência fui fazendo aos poucos e até que finalmente tinha o resultado na tela:

 

Resultado do teste dos caracteres na tela do Color, no modo RG6.

  

Minha ferramenta de edição no MSX, de onde obtive os dados dos caracteres.

Dados dos caracteres em hexadecimal.

 

Fiz ainda um pequeno ajuste, já que os caracteres do MSX são justificados do lado esquerdo e apareciam "colados" com a margem esquerda da tela do Color, o que me incomodou, esteticamente. A solução foi um deslocamento de bits para a direita. O BASIC não tem instrução de deslocamento de bits, é verdade, mas a matemática básica salva: para deslocar bits de um número binário para a direita é só tomar o valor inteiro do número dividido por dois. Uma pequena rotina deu conta fazer isso com os 736 bytes dos 92 caracteres que utilizei.

Depois foi questão de elaborar o programa em si para manipular os dados na tela. Fiz isso utilizando o Disk Edtasm 6309, ferramenta nativa do Color, como montador para o 6809.

Todos os efeitos das outras versões foram reproduzidos: cada coluna tem um delay para iniciar a descida dos caracteres e o seu apagamento; quatro velocidades diferentes para a escrita e apagamento dos caracteres, sorteadas a cada reinício de cada coluna; e finalmente, caracteres já escritos são sobrescritos por caracteres aleatórios (seriam "patches" na Matrix?). Para destacar o primeiro caractere que vai descendo pela tela em cada coluna, utilizei o velho truque deslocamento de bits para gerar o caractere bold. Poderia ter utilizado os caracteres bold pré-processados, mas acabei programando a geração dos mesmos on the fly.

Acredito que o resultado ficou muito bom, um pouco atrás apenas da versão para MSX, cuja coluna descendente tem 3 tons de verde além do caractere branco como destaque.

Download: Matrix-TRS-Color.dsk

  

The Matrix has you.

Demo do Color Clube Brasil - TRS-Color

Fazia tempos que não fazia nada para o Color. Desde o Color Poker, mergulhei profundamente no universo do Z80 e fiz um bocado de coisas no MSX, algumas outras no TK-85 (ZX81) e ainda um par de coisas para o TRS-80.

Há alguns anos eu adquiri um CP-400, igual àquele que foi o primeiro computador que tive, lá em 1985. Mas acabei não usando muito, porque começou a apresentar um problema de vídeo. Até que esses dias resolvi finalmente arrumar e, ele novo de novo, de tão bom que ficou me animou a fazer alguma coisa para rodar nele.

Inspirado no efeito de abertura dos episódios do canal do 8-Bit Guy, resolvi fazer algo do gênero para o Color, que na realidade já tinha feito no MSX e depois para o TK 85 há algum tempo. 

Primeiro fiz uma tela em homenagem ao Clube Color Brasil (grupo do Facebook) utilizando o modo semigráfico (e bastante colorido) do Color para poder utilizar o efeito em cima dela. Ou melhor, na realidade, a tela vai surgindo a partir do efeito. Em seguida, joguei mais um efeito de troca de cores e finalmente um scroll up para recomeçar o efeito inicial. Olha aí:

 

 

O Assembly 6809

Apesar da minha experiência com o Color BASIC do TRS-Color, o assembly da CPU Motorola 6809 era para mim um mistério. Mas sempre tive muita curiosidade, até para conhecer as diferenças em relação ao assembly Z80. Então lá fui eu apreender "uma nova língua". O montador que uso é o Disk EDTASM++ (ferramenta nativa).  A vantagem de usar esse montador é que ele é muito similar ao EDTASM para o TRS-80, no qual já tenho alguma experiência, já que fiz versões do Matrix e do Doom Fire para TRS-80 (todos disponíveis aqui no blog).

Para o assembly, meu guia tem sido o didático TRS-80 Color Computer Assembly Language Programming, do Willian Barden Jr. Utilizei também outros materiais esparsos, de maior profundidade técnica, que me ajudaram a compreender como o SAM e o VDG interagem e, especificamente, como é feita a seleção dos modos gráficos em baixo nível. Se alguém for se aventurar, não se esqueça de que além de setar os registradores do modo gráfico escolhido, é preciso também definir o offset das páginas gráficas. De nada.

A diferença entre o assembly do 6809 para o do Z80 é substancial, tendo o 6809 mais recursos e flexibilidade. Para além do conjunto de instruções e sua sintaxe, levei um tempo para me acostumar com a notação que diferencia o endereçamento direto e indireto e com o prefixo obrigatório "$" para hexadecimal, que nunca utilizei com o Z80. Pode parecer bobagem, mas de início essa diferença de notação me dificultava bastante a leitura do que estava na tela. Meu cérebro, desde os 15 anos, estava acostumado com endereçamento indireto indicado de forma muito clara com parênteses, somado ao fato de que eu uso o sufixo "H", e não o prefixo "$", para notação de hexadecimais.

Mas enfim, o programinha simples serviu muito bem como iniciação. Logo faço algo um pouco mais complexo.

Download da imagem do disco: CCB-Demo.dsk

Para carregar: LOADM "CCBDEMO.BIN"

Para executar: EXEC

Para sair: segure a tecla BREAK