Codificar e testar um computador em linguagem de máquina: 6 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

Neste Instructable, vou mostrar como codificar e testar um programa de computador em linguagem de máquina. A linguagem de máquina é a linguagem nativa dos computadores. Por ser composto de sequências de 1s e 0s, não é facilmente compreendido por humanos. Para contornar isso, primeiro codificamos programas em uma linguagem de alto nível como C ++ ou Java e, em seguida, usamos programas de computador especiais para traduzi-los para os 1s e 0s que os computadores entendem. Aprender a codificar em uma linguagem de alto nível é certamente um acéfalo, mas uma breve introdução à linguagem de máquina pode fornecer informações valiosas sobre como os computadores funcionam e aumentar a apreciação desta tecnologia muito importante.

Para codificar e testar um programa de linguagem de máquina, precisamos acessar um computador simples, cuja linguagem de máquina seja facilmente compreendida. Os computadores pessoais são complexos demais para sequer serem considerados. A solução é usar o Logisim, um simulador lógico, que roda em um computador pessoal. Com o Logisim podemos simular um computador que atenda às nossas necessidades. O vídeo acima dá uma ideia do que podemos realizar com o Logisim.

Para o design do computador, adaptei um do meu e-book Kindle Build Your Own Computer - From Scratch. Comecei com o computador BYOC descrito lá e reduzi-o para o BYOC-I básico variado (I para Instructable) que usaremos neste Instructable.

A linguagem de máquina do BYOC-I é simples e fácil de entender. Você não precisará de nenhum conhecimento especial de computadores ou programação. Tudo o que é necessário é uma mente curiosa e desejo de aprender

Leitura Adicional

Você pode se perguntar por que usamos "máquina" para descrever um computador quando ele não é um dispositivo mecânico. O motivo é histórico; os primeiros dispositivos de computação eram mecânicos, consistindo em engrenagens e rodas. A letra de Allan Sherman, "Era tudo engrenado clic-clac …" tinha apenas um século ou dois. Leia mais sobre a computação inicial aqui.

Etapa 1: Lista de peças

A lista de peças é curta. Apenas estes dois itens são necessários, ambos para download gratuito:

1. "Logisim-win-2.7.1.exe" - Logisim é um simulador lógico popular e fácil de usar. Baixe o arquivo executável Logisim aqui e crie um atalho em um local conveniente como sua área de trabalho. Clique duas vezes no ícone Logisim para iniciá-lo. Nota: Logisim usa o pacote Java Runtime localizado aqui. Você pode ser solicitado a fazer o download.
2. BYOC-I-Full.cir "- Baixe o arquivo de circuito Logisim abaixo.

Inicie o Logisim e clique em "File-Open" e carregue o arquivo BYOC-I-Full.cir. A imagem acima mostra o ambiente de trabalho do Logisim. O BYOC-I é representado pelo bloco de subcircuito. Duas entradas são conectadas externamente, Reset e Run, e exibições hexadecimais para os registros do BYOC-I e a memória do programa.

A memória de programa do BYOC-I é pré-carregada com um programa simples que conta de 1 a 5 no registrador A. Para executar (Executar) o programa, siga estas etapas.

Passo 1 - Clique na ferramenta Poke. O cursor deve mudar para o "dedo" cutucando. Passo 2 - Pressione a entrada Reset duas vezes, uma vez alterando para "1" e novamente para alterá-la de volta para "0". Isso reinicializa o BYOC-I para iniciar o programa no endereço 0. Etapa 3 - Pressione a entrada Executar uma vez para alterá-la para "1". O registro A deve mostrar a contagem mudando de 1 a 5 e então repetindo. Etapa 4 - Se o programa não for executado, pressione control-K e ele deve iniciar.

Se você deseja explorar os recursos do Logisim, clique no link Ajuda na Barra de Menu. A partir daí, você pode explorar o "Tutorial", "Guia do usuário" e "Referência da biblioteca" do Logisim. Um excelente vídeo de introdução pode ser encontrado aqui.

Etapa 2: Códigos e hierarquia da linguagem de máquina

O computador BYOC-I executa tarefas com base em programas escritos em linguagem de máquina. Os programas BYOC-I, por sua vez, são compostos por instruções executadas em uma sequência bem definida. Cada instrução é feita de códigos de comprimento fixo que representam vários componentes operacionais do BYOC-I. Finalmente, esses códigos consistem em cadeias de 1s e 0s que constituem a linguagem de máquina que o BYOC-I realmente executa.

A título de explicação, começaremos com códigos e subiremos até o nível do programa. Em seguida, iremos codificar um programa simples, carregá-lo na memória do BYOC-I e executá-lo.

Os códigos consistem em um número fixo de dígitos binários (1 e 0) ou bits, para abreviar. Por exemplo, a tabela abaixo mostra todos os códigos possíveis (16 no total) para um código de 4 bits de largura. Ao lado do código, é mostrado o hexadecimal (base 16) e o equivalente decimal. Hexadecimal é usado para se referir a valores binários, pois é mais compacto do que binário e mais fácil de converter de binário do que decimal. O prefixo "0x" permite que você saiba que o número a seguir é hexadecimal ou "hex" para abreviar.

Binário - Hexadecimal - Decimal0000 0x0000 00001 0x0001 10010 0x0002 20011 0x0003 30100 0x0004 40101 0x0005 50111 0x0007 71000 0x0008 81001 0x0009 91010 0x000A 101011 0x000B 111100 0x000C 121101 0x000D 131110 0x000E 141111 0x000B 15

A largura de um código determina quantos itens podem ser representados. Conforme observado, o código de 4 bits acima pode representar até 16 itens (0 a 15); isto é, 2 vezes 2 tomado quatro vezes ou 2 à 4ª potência é igual a 16. Em geral, o número de itens representáveis é 2 elevado à enésima potência. Aqui está uma pequena lista de capacidades de código de n bits.

n - Número de itens 1 22 43 84 165 326 647 1288 256

As larguras do código de computador BYOC-I são escolhidas para acomodar o número de itens a serem representados pelo código. Por exemplo, existem quatro tipos de instrução, portanto, um código amplo de 2 bits é adequado. Aqui estão os códigos BYOC-I com uma breve explicação de cada um.

Código de tipo de instrução (tt) Existem quatro tipos de instruções: (1) MVI - Mova um valor constante de 8 bits imediato para um registro de memória. O registro de memória é um dispositivo que contém dados a serem usados para um cálculo, (2) MOV - Mover dados de um registro para outro, (3) RRC - Realizar um cálculo de registro para registro, e (4) JMP - Saltar para uma instrução diferente em vez de continuar na próxima instrução. Os Códigos de Tipo de Instrução BYOC-I adotados são os seguintes:

00 MVI01 MOV10 RRC11 JMP

Código de registro (dd e ss) O BYOC-I tem quatro registros de 8 bits capazes de armazenar valores de 0 a 255. Um código de 2 bits é suficiente para designar os quatro registros:

00 F registrador01 E registrador10 D registrador11 A registrador

Código de cálculo (ccc) O BYOC-I oferece suporte a quatro operações aritméticas / lógicas. Para permitir a expansão futura para oito cálculos, um código de 3 bits é usado:

000 ADD, adicionar dois valores de 8 bits nos registros designados e armazenar o resultado em um dos registros 001 SUB, subtrair dois valores de 8 bits nos registros designados e armazenar o resultado em um dos registros 010 - 011 Reservado para uso futuro100 E, logicamente AND dois valores de 8 bits em registros designados e armazenar o resultado em um dos registros101 OR, logicamente OR dois valores de 8 bits em registros designados e armazenar o resultado em um dos registros 110 a 111, Reservado para uso futuro

Código de salto (j) Um código de 1 bit que indica se o salto é incondicional (j = 1) ou condicionado a um resultado de cálculo diferente de zero (j = 0).

Dados / Código de endereço (v… v) / (a… a) Dados de 8 bits podem ser incluídos em certas instruções que representam valores de 00000000 a 11111111 ou 0 a 255 decimal. Esses dados têm largura de 8 bits para armazenamento nos registradores de 8 bits do BYOC-I. Com a aritmética decimal, não mostramos zeros à esquerda. Com a aritmética do computador, mostramos os zeros à esquerda, mas eles não afetam o valor. 00000101 é numericamente igual a 101 ou 5 casas decimais.

Referências sugeridas

Notação binária - https://learn.sparkfun.com/tutorials/binaryHexadecimal Notação -

Leitura Adicional

A ideia de usar códigos para conduzir um processo é antiga. Um exemplo fascinante é o Jacquard Loom. O tear automatizado era controlado por uma corrente de cartões de madeira em que furos eram perfurados representando códigos para fios de cores diferentes para tecelagem. Eu vi meu primeiro na Escócia, onde foi usado para fazer tartans coloridos. Leia mais sobre Jacquard Looms aqui.

Etapa 3: anatomia das instruções BYOC-I

Dados os códigos do BYOC-I, passamos para o próximo nível, as instruções. Para criar uma instrução para o BYOC-I, colocamos os códigos juntos na ordem especificada e em locais específicos dentro da instrução. Nem todos os códigos aparecem em todas as instruções, mas, quando o fazem, ocupam um local específico.

O tipo de instrução MVI requer a maioria dos bits, 12 ao todo. Ao tornar a palavra de instrução de 12 bits, acomodamos todas as instruções. Os bits não usados (chamados de "não se importam") recebem o valor 0. Aqui está o Conjunto de instruções BYOC-I.

1. Mover Imediato (MVI) - 00 dd vvvvvvvvFunção: Mova um valor de dados de 8 bits V = vvvvvvvv para o registrador de destino dd. Após a execução, o registro dd terá o valor vvvvvvvv. Abreviatura: MVI R, V onde R é A, D, E ou F. Exemplo: 00 10 00000101 - MVI D, 5 - Mova o valor 5 para o registrador D.
2. Mover registrador para registrar (MOV) - 01 dd ss 000000Função: Mover dados do registrador de origem ss para o registrador de destino dd. Após a execução, ambos os registros têm o mesmo valor do registro de origem. Abreviação: MOV Rd, Rs onde Rd é o registrador de destino A, D, E ou F e Rs é o registrador de origem A, D, E ou F. Exemplo: 01 11 01 000000 - MOV A, E - Mova o valor no registro E para registrar A.
3. Register to Register Calculation (RRC) - 10 dd ss ccc 000Função: Execute o cálculo designado ccc usando o registrador de origem ss e o registrador de destino dd, em seguida, armazenando o resultado no registrador de destino. Abreviações: ADD Rd, Rs (ccc = 000 Rd + Rs armazenados em Rd); SUB Rd, Rs (ccc = 001 Rd - Rs armazenado em Rd); AND Rd, Rs (ccc = 100 Rd AND Rs armazenados em Rd); OR Rd, Rs (ccc = 101 Rd OR Rs armazenados em Rd). Exemplo: 10 00 11 001 000 - SUB F, A - Subtraia o valor no registro A do registro F com o resultado no registro F.
4. Jump to Different Instruction (JMP) - 11 j 0 aaaaaaaaFunção: Alterar a execução para uma instrução diferente localizada no endereço aaaa aaaa (a) Incondicionalmente (j = 1) -11 1 0 aaaaaaaaAbbreviation: JMP L onde L é o endereço aaaa aaaaExemplo: 11 1 0 00001000 - JMP 8 - Mude a execução para o endereço 8. (b) Condicionalmente (j = 0) quando o cálculo anterior resultou em um resultado diferente de zero - 11 0 0 aaaaaaaaAbbreviação: JNZ L onde L é o endereço aaaa aaaa. Exemplo: 11 0 0 00000100 JNZ 4 Se o último cálculo gerou um valor diferente de zero, altere a execução para o endereço 4.

Os bits da palavra de instrução são numerados da esquerda (bit mais significativo MSB) para a direita (bit menos significativo LSB) de 11 a 0. A ordem fixa e as localizações dos códigos são as seguintes:

Bits - Code11-10 Instruction Type9-8 Destination Register7-6 Source Register5-3 Cálculo: 000 - add; 001 - subtrair; 100 - AND lógico; 101 - valor constante lógico OR7-0 v… v e a… a (0 a 255)

O conjunto de instruções está resumido na figura acima. Observe a aparência estruturada e ordenada dos códigos em cada instrução. O resultado é um design mais simples para o BYOC-I e torna as instruções mais fáceis de entender.

Etapa 4: Codificando uma Instrução de Computador

Antes de passar para o nível de programa, vamos construir algumas instruções de exemplo usando o conjunto de instruções BYOC-I acima.

1. Mova o valor 1 para o registrador A. Os registradores BYOC-I podem armazenar valores de 0 a 255. Neste caso, o registrador A terá o valor 1 (00000001 binário) após a execução da instrução.

Abreviatura: MVI A, 1 Códigos requeridos: Tipo MVI - 00; Registro de destino A - 11; Valor - 00000001 Palavra de instrução: 00 11 00000001

2. Mova o conteúdo do registro A para o registro D. Após a execução, ambos os registros terão o valor originalmente no registro A.

Abreviatura: MOV D, A (Lembre-se, o destino é o primeiro e a origem é o segundo na lista) Códigos requeridos: Tipo MOV - 01; Registro de destino D - 10; Registro de fonte A - 11 Palavra de instrução: 01 10 11 000000

3. Adicione o conteúdo do registro D ao registro A e armazene no registro A. Após a execução, o valor do registro A será a soma do valor original do registro A e do registro D.

Abreviação: ADD A, D (o resultado é armazenado no registro de destino) Códigos necessários: Tipo RRC - 10; Registro de destino A - 11; Registrador de origem D - 10; Cálculo Adicionar - 000 Palavra de instrução: 10 11 10 000 000 (ccc é o primeiro 000 - adicionar)

4. Vá para o endereço diferente de zero. Se o resultado do último cálculo não for zero, a execução mudará para a instrução no endereço fornecido. Se zero, a execução recomeça na instrução seguinte.

Abreviatura: JNZ 3Códigos necessários: Tipo JMP-11; Tipo de salto - 0; Endereço - 00000003 Palavra de instrução: 11 0 0 00000003 (o tipo de salto é o primeiro 0)

5. Salte incondicional para o endereço 0. Após a execução, a execução muda para a instrução no endereço fornecido.

Abreviatura: JMP 0Código Obrigatório: Tipo JMP - 11; Tipo de salto - 1; Endereço - 00000000 Palavra de instrução; 11 1 0 00000000

Embora a codificação de máquina seja um tanto entediante, você pode ver que não é impossivelmente difícil. Se você estivesse codificando por máquina de verdade, usaria um programa de computador chamado assembler para traduzir da abreviatura (que é chamada de código de montagem) para o código de máquina.

Etapa 5: anatomia de um programa de computador

Um programa de computador é uma lista de instruções que o computador executa, começando no início da lista, continuando na lista até o fim. Instruções como JNZ e JMP podem alterar qual instrução é executada a seguir. Cada instrução da lista ocupa um único endereço na memória do computador, começando em 0. A memória BYOC-I pode conter uma lista de 256 instruções, mais do que o suficiente para nossos propósitos.

Os programas de computador são projetados para executar uma determinada tarefa. Para o nosso programa, vamos escolher uma tarefa simples, contando de 1 a 5. Obviamente, não há nenhuma instrução de "contagem", então o primeiro passo é dividir a tarefa em etapas que podem ser manipuladas pelos próprios BYOC-I's conjunto de instruções limitado.

Etapa 1 Mova 1 para registrar AStep 2 Mova o registro A para registrar DStep 3 Adicione o registro D para registrar A e armazene o resultado no registro AStep 4 Mova 5 para registrar EStep 5 Subtraia o registro A do registro E e armazene o resultado no registro EStep 6 Se o resultado da subtração não foi zero, volte para a Etapa 4 e continue contando. Etapa 7 Se o resultado da subtração for zero, volte e recomece

A próxima etapa é traduzir essas etapas em instruções BYOC-I. Os programas BYOC-I começam no endereço 0 e são numerados consecutivamente. Os endereços de destino de salto são adicionados por último, depois que todas as instruções estão em vigor.

Endereço: Instrução - Abreviatura; Descrição0: 00 11 00000001 - MVI A, 1; Mova 1 para o registro A1: 01 10 11 000000 - MOV D, A; Mova o registro A para o registro D2: 10 11 10 000 000 - ADD A, D; Adicionar o registro D ao registro A e armazenar o resultado no registro A3: 00 01 00 00000101 - MVI E, 5; Mover 5 registro E4: 10 01 11 001 000 - SUB E, A; Subtrair o registro A do registro E e armazenar o resultado no registro E5: 11 0 0 00000010 - JNZ 2; Se o resultado da subtração não foi zero, volte para o endereço 3 e continue contando 6: 11 1 0 00000000 - JMP 0; Se o resultado da subtração foi zero, volte e recomece

Antes de transferir o programa para a memória, o código de instrução binário deve ser alterado para hexadecimal para usar com o Editor Logisim Hex. Primeiro, divida a instrução em três grupos de 4 bits cada. Em seguida, traduza os grupos em hexadecimais usando a tabela da Etapa 2. Somente os três últimos dígitos hexadecimais (em negrito abaixo) serão usados.

Endereço - Instrução binário - Instrução Binary Split - Instrução (Hex) 0 001100000001 0011 0000 0001 - 0x03011 011011000000 0110 1100 0000 - 0x06C02 101110000000 1011 1000 0000 - 0x0B803 000100000101 0001 0000 0101 - 0x01054 100111001000 1001 1100 1000 - 0x09C85 110000000100 1100 0000 0010 - 0x0C026 111000000010 1110 0000 0000 - 0x0E00

É hora de transferir o programa para a memória do BYOC-I para teste.

Etapa 6: Transferência do programa para a memória e teste

Olhando para o circuito "principal" do Logisim, o bloco BYOC-I mostrado é o símbolo do circuito do computador real denominado "BYOC-I" no painel Explorer. Para inserir um programa na memória BYOC-I:

1. Clique com o botão direito do mouse no bloco BYOC-I (chamado de "subcircuito") e selecione (passe o mouse e clique com o botão esquerdo) "Exibir BYOC-I".
2. O circuito BYOC-I aparecerá na área de trabalho. Clique com o botão direito no símbolo "Program Memory" e selecione "Edit Contents..".
3. Usando o Logisim Hex Editor, insira o código hexadecimal (somente negrito) conforme mostrado acima.

Agora você está pronto para executar o programa. Retorne ao circuito principal clicando duas vezes em "BYOC-I" no painel do Explorer. As entradas Run e Reset devem ser "0" para iniciar. Usando a ferramenta Poke, primeiro altere Reset para "1" e depois de volta para "0". Isso cria o endereço inicial 0x0000 e prepara o circuito BYOC-I para execução. Agora coloque a entrada Run em "1" e o programa será executado. (Observação: você precisa tocar em Control-K uma vez para iniciar o relógio Logisim. Este é um recurso que permite parar o relógio Logisim e percorrer um programa tocando em Control-T repetidamente. Tente algum dia!)

O relógio Logisim pode ser configurado para uma ampla faixa de frequências. O download é de 8 Hz (8 ciclos por segundo). Da maneira como o computador BYOC-I é projetado, cada instrução leva quatro ciclos de clock para ser concluída. Portanto, para calcular a velocidade do BYOC-I, divida a frequência do clock por 4. A 8 Hz, sua velocidade é de 2 instruções por segundo. Você pode alterar o relógio clicando em "Simular" na barra de ferramentas e selecionando "Frequência do tique". O intervalo possível é de 0,25 Hz a 4100 Hz. A velocidade lenta em 8 Hz foi escolhida para que você pudesse assistir a contagem no registro A.

A velocidade máxima da simulação BYOC-I (~ 1000 instruções por segundo) é muito lenta em comparação com os computadores modernos. A versão de hardware do computador BYOC descrita em meu livro executa a mais de 12 milhões de instruções por segundo!

Espero que este Instructable tenha desmistificado a programação em linguagem de máquina e tenha dado a você uma visão de como os computadores funcionam em seu nível mais básico. Para firmar seu entendimento, tente codificar os dois programas abaixo.

1. Escreva um programa que comece em 5 e faça a contagem regressiva até 0. (ANS. Count5to0.txt abaixo)
2. Começando com 2, conte por 3 até que o número exceda 7. Você poderia fazer um pouco de aritmética mental, verificar 8 sabendo que ele cairia lá e reinicie. Escreva seu programa de uma maneira mais geral que realmente teste se a contagem "excede" um número específico. Dica: explore o que acontece quando uma subtração produz um valor negativo, digamos 8 - 9 = -1 por exemplo. Em seguida, experimente o AND lógico para testar se o MSB em um número de 8 bits é "1". (ANS. ExceedsCount.txt)

Você consegue pensar em outros problemas desafiadores para o computador BYOC-I? Dadas suas limitações, o que mais ele pode fazer? Compartilhe suas experiências comigo em [email protected]. Se você estiver interessado em codificar microprocessadores, visite meu site www.whippleway.com. Lá eu levo a codificação da máquina para processadores modernos, como a série ATMEL Mega usada nos Arduinos.