Programador de computador breadboard
Componentes e suprimentos
 |
| × | 1 |
Sobre este projeto
Que projeto é esse?
Esta é uma extensão do projeto de computador de placa de ensaio de 8 bits de Ben Eater. Eu gostei imensamente de acompanhar os vídeos de Ben sobre como construir um computador protoboard e construir minha própria versão dele. Se você não tem acompanhado Ben, eu recomendo fortemente que assista a seus vídeos antes de ler - este projeto fará muito pouco sentido sem o contexto.
Depois de construir o computador, rapidamente ficou claro que, se eu tivesse que alternar manualmente em um programa por meio de interruptores DIP toda vez que o ligasse, ele não teria muita utilidade. Até mesmo alternar em apenas 16 bytes repetidamente envelhece muito rápido. Também estava planejando estender a memória para 256 bytes e isso só seria útil se de alguma forma os programas pudessem ser carregados e salvos.
O que posso fazer com isso?
- Salve um programa da RAM do computador breadboard
- Carregue um programa na RAM do computador breadboard
- Executar automaticamente um programa salvo quando o computador protoboard inicia
- Inspecione e modifique o conteúdo da memória por meio de uma conexão serial
- Programe o computador breadboard em linguagem assembly
- Desmonte o conteúdo da memória
- Instrução de etapa única por instrução
- Defina pontos de interrupção e execute até o ponto de interrupção
Aqui está um vídeo demonstrando esses recursos. Desculpe a qualidade do vídeo - não sou, de forma alguma, um criador profissional de conteúdo de vídeo:
Como funciona?
Eu tinha alguns objetivos em mente ao fazer este projeto:
- O mínimo possível de hardware necessário para construí-lo
- O mínimo possível de alterações no próprio computador breadboard
No início, pensei em usar uma EEPROM para armazenar programas e, em seguida, algum tipo de lógica para transferir programas da EEPROM para a RAM do computador breadboard. No entanto, criar a lógica de transferência provou ser mais complicado do que eu poderia lidar (eu sou mais um cara de software, embora eu realmente goste de trabalhar perto de hardware). Acontece que sou um grande fã do Arduino, então em algum momento comecei a pensar em substituir a lógica de transferência por um Arduino. Levei algum tempo para me convencer de que usar um Arduino não era trapaça (afinal, até o Arduino UNO é muito mais poderoso do que o próprio computador protoboard), mas estou feliz com o resultado, então fiz as pazes.
Então, o que o Arduino precisa ser capaz de fazer? Bem, ele precisa ser capaz de ler dados da memória e gravar dados na memória. A maneira mais fácil e menos intrusiva (para o computador de placa de ensaio) de fazer isso é usar a mesma interface que o módulo de memória já possui:o barramento e os sinais de controle. Os pinos de E / S digital do Arduino são bidirecionais, portanto, conectar 8 deles diretamente ao barramento permite que o Arduino leia e grave no barramento. Para fazer com que o módulo de RAM leia ou escreva no barramento, tudo o que é necessário é definir os sinais MI / RI / RO de acordo. Agora, esses sinais são normalmente conduzidos pelos EEPROMs da lógica de controle, portanto, ter o Arduino controlando-os também levaria a conflitos e possíveis situações de curto-circuito. No entanto, o AT28C16 EEPROMS usado por Ben tem uma entrada Chip Enable (CE) que coloca todas as saídas de dados em um estado high-z - o que permite ao Arduino manipular os sinais. Para ler a RAM, o Arduino precisa fazer o seguinte:
- definir o sinal CE da EEPROM alto (ou seja, desabilitar a lógica de controle)
- enviar o primeiro endereço a ser lido no ônibus
- defina o sinal de MI alto e espere por uma transição de baixo-alto do relógio
- defina MI baixo e RO alto e espere por uma transição de baixo-alto de clock
- leia o byte de dados do ônibus
- repita a partir da etapa 2 para todos os 16 endereços
- definir o sinal CE da EEPROM baixo (ou seja, reativar a lógica de controle)
E é isso. Gravar o conteúdo da RAM é muito semelhante, o Arduino só precisa gravar no barramento e definir RI alto em vez de RO. É claro que há alguns problemas técnicos a serem resolvidos, mas o mecanismo básico acima é o coração deste projeto.
Que mudanças preciso fazer no computador protoboard?
Existem duas mudanças que precisam ser feitas:
- Coloque resistores pull-down nas saídas de dados da EEPROM da lógica de controle
- Desative (ou reinicie continuamente) o contador de toque enquanto a EEPROM está desativada
Resistores pull-down
Os resistores pull-down são necessários porque, uma vez que a EEPROM é desabilitada, os resistores pull-up das portas lógicas aos quais os sinais de controle (como AO / AI / EO ...) estão conectados puxarão esses sinais para alto. Isso significaria que vários registradores estariam gravando no barramento, causando conflitos.
Os resistores pull-up nas entradas das portas 74LS têm cerca de 10k. Portanto, os resistores pull-down precisam ser pequenos o suficiente para baixar a tensão em território baixo. Para a maioria das linhas de sinal, usei resistores de 3,3 kOhm. No entanto, há duas exceções:primeiro, o sinal "SU" é conectado a 8 portas OR exclusivas, o que significa que o resistor pull-up efetivo é 10kOhm / 8 =1,25kOhm. Um resistor pull-down teria que ser significativamente menor que 1k para puxar para baixo. Felizmente, o sinal SU (subtrair) não controla nenhuma interação com o barramento, portanto, podemos simplesmente ignorá-lo e não ter um resistor pull-down. Em segundo lugar, o CE (contador habilitado) precisava de um resistor pull-down de 1k - valores maiores causavam comportamento de contador de programa aleatório em alguns casos.
Achei mais fácil adicionar os resistores pull-down na placa de ensaio que contém todos os LEDs azuis, ou seja, entre os ânodos de LED (que estão conectados às saídas EEPROM) e GND.
[Não consegui encaixar os resistores aqui para os sinais HLT / MI / RI, então adicionei aqueles em outros locais na placa de ensaio]
Redefinição do contador de toque
A outra modificação é redefinir o contador de toque. Tecnicamente, isso não é realmente necessário para permitir o salvamento / carregamento de programas, mas permite uma transferência suave do controle do Arduino de volta para a lógica de controle. O objetivo é manter o contador de anel em 0 enquanto CE estiver alto (ou seja, a lógica de controle está desabilitada). Quando o Arduino muda o CE de volta para baixo (habilitando a lógica de controle), o contador de anéis estará em zero e o computador breadboard começa a executar a próxima instrução.
Para minha construção, não precisei fazer nada porque estou usando uma saída EEPROM para zerar o contador de toque. Isso melhora o desempenho, redefinindo o contador de toque assim que uma instrução é concluída. Ele também me dá automaticamente a reinicialização do contador de anel quando a lógica de controle EEPROM é desabilitada:o resistor pull-down na saída da EEPROM puxará o sinal para baixo, o que reinicializa o contador de anel.
Se você estiver usando a implementação de Ben de um contador de anel fixo de 5 etapas, acho que a seguinte extensão de seu circuito de redefinição deve zerar o contador quando CE for alto (clique nas setas esquerda / direita abaixo para alternar entre o circuito original de Ben e o versão extendida):
Como você pode ver, ele requer mais 3 portas NAND, ou seja, mais um chip 74LS00. Observe que não testei essa abordagem, mas deve funcionar, pelo que posso ver.
Essa modificação não é absolutamente necessária - você pode deixá-la de fora no início. Carregar e salvar, bem como o monitor / montador / desmontador ainda funcionarão bem. No entanto, qualquer ação que requeira transferência de controle do Arduino para a lógica de controle não funcionará. Mais notavelmente, é a execução automática de programas salvos na inicialização, bem como a execução de uma única etapa no depurador.
Como faço para configurar o Arduino?
Faça upload do esboço do arquivo GIT para o Arduino e conecte o Arduino ao computador breadboard da seguinte maneira:
- pino do Arduino 5V ( não Vin!) Para trilho de 5 V na placa de ensaio
- pino GND do Arduino para pino GND na placa de ensaio
- pinos digitais do Arduino 2-9 para o barramento 0-7
- Arduino digital pin 10 para controlar a saída EEPROM lógica que controla RO
- Arduino pino digital 11 para controlar a saída EEPROM lógica que controla RI
- Arduino digital pin 12 para controlar a saída EEPROM lógica que controla MI
- pino analógico do Arduino 0 para sinal do CLOCK
- Arduino analógico pino 3 a CE (pino 18) de todos lógica de controle EEPROMs e através de um resistor de 10k para + 5v
Além disso, você precisará conectar os pinos de entrada analógica 1 e analógica 2 do Arduino aos interruptores DIP e botões de pressão, conforme mostrado nos esquemas (para obter mais detalhes, consulte o arquivo Fritzing em anexo).
Para uma versão mínima absoluta (mas ainda funcional), você pode fazer o seguinte:
- Adicione resistores pull-down de 3,3 kOhm aos pinos de saída EEPROM que controlam AO, CO, EO, IO, RO
- Ignore as instruções de "Redefinição do contador de toque" acima
- Faça o Arduino para conectar a fiação do computador à placa de ensaio conforme mostrado acima (você pode deixar de fora o resistor de 10k na última etapa, se desejar)
- Conecte o pino 1 analógico e o pino 2 analógico ao GND
Para usar os botões carregar / salvar, tudo que você precisa fazer é conectar os botões, interruptores DIP e resistores associados aos pinos analógicos 1 e 2 de acordo com o esquema.
Para usar o recurso de inicialização automática, o Arduino precisa manter o contador do programa em e o contador de toque em 0 durante a reinicialização e enquanto o programa é transferido. O resistor pull-up entre o pino analógico 3 e + 5V mantém a lógica de controle desabilitada (e, portanto, o contador do programa em 0) enquanto o Arduino reinicia. Para o contador de toque, siga as instruções "Reinicialização do contador de toque" acima.
Como carrego e salvo programas?
A configuração mínima acima permitirá que você controle o Arduino por meio da interface serial. Para se comunicar com o Arduino, você precisará de um programa de terminal como Putty ou TeraTerm. O monitor serial no software Arduino também funcionará, mas a separação entre a área de entrada e saída no monitor serial o torna um pouco desajeitado neste cenário.
- Ligue o computador da placa de ensaio
- Conecte um PC ao Arduino por meio do cabo USB
- Inicie o programa do terminal e configure para 9600 baud, 8 bits, sem paridade, 1 bit de parada
- Pressione ESC na janela do terminal para entrar no modo Monitor
- Você deve ver um "." como um prompt de comando
- Digite "h" e pressione Enter para obter uma lista de comandos compatíveis
Com a configuração mínima, você deve ser capaz de usar os comandos "m", "M", "C", "l" e "s". Isso permite que você veja o conteúdo da memória, modifique o conteúdo da memória e carregue e salve programas.
Para salvar ou carregar um programa por meio do botão:
- Desligue o relógio do computador breadboard
- Defina as chaves DIP para selecionar o número do arquivo no qual os dados devem ser salvos.
- Pressione o botão "salvar" ou "carregar". O LED conectado ao CE acenderá, indicando que o Arduino assumiu o controle
- Ligue o relógio do computador breadboard. Você deve ver o Arduino percorrendo os endereços (observe os LEDs do registro de endereço de memória)
- Espere até que os LEDs do barramento parem de piscar e os LEDs do registro do endereço de memória mostrem 1111
- Desligue o relógio do computador breadboard. O LED conectado ao CE apagará, indicando que o controle voltou para a lógica de controle
Para executar um programa automaticamente na inicialização (certifique-se de ter todos os circuitos necessários no lugar), apenas defina as chaves DIP para o número do arquivo no qual o programa foi salvo e ligue o computador breadboard (ou pressione o botão reset). Existem dois casos especiais:Se todos os interruptores DIP estiverem desligados, o computador é inicializado regularmente, sem inicialização automática. Se todos os interruptores DIP estiverem ligados, o Arduino entrará no modo Monitor diretamente na inicialização.
Como faço para usar o montador e o desmontador?
Para usar os recursos do montador / desmontador e do depurador, primeiro você precisa alterar o programa no Arduino para estar de acordo com sua configuração específica. Encontre a seção no código-fonte que define a estrutura opcodes_4bit:
struct opcodes_struct opcodes_4bit [] ={{"NOP", B00000000, 0, false}, {"LDA", B00010000, 2, true}, ... {".OR", B11111110, 0, true}, // definir endereço inicial {".BY", B11111111, 0, true}, // definir um byte de dados {NULL, 0, 0, false}}; Cada linha especifica um opcode:
- O primeiro campo é o mnemônico ("LDA"). Para endereçamento imediato, inclua um "#" no mnemônico. Portanto, o que Ben chama de "LDI" seria chamado de "LDA #" aqui. Você pode dizer que eu cresci programando 6510 assembler em um C64?
- O segundo campo é o próprio opcode. Os quatro bits inferiores devem ser sempre 0. (exceto para os opcodes especiais .OR e .BY, veja abaixo)
- O terceiro campo é o número de ciclos que o opcode leva para executar (além dos ciclos de busca). Por exemplo, em minha implementação, LDA tem opcode 0001 e leva um total de quatro ciclos para ser executado, dois dos quais são o ciclo de busca. Se você seguiu as instruções de Ben (em que todos os opcodes usam 5 ciclos), este deve ser sempre 3.
- O último campo especifica se este opcode requer um argumento. Por exemplo, LDA requer um argumento, mas OUT não.
Você precisará ajustar esta lista para refletir os opcodes que você implementou para o seu computador breadboard. As duas últimas linhas são opcodes especiais usados pelo montador e devem ser deixadas como estão.
Depois de inserir todos os seus opcodes, faça upload do software para o Arduino. Conecte seu terminal e vá para o modo Monitor (pressionando ESC na janela do terminal ou configurando todas as chaves DIP para ativadas). Agora você deve conseguir desmontar seu programa. Digitar apenas "d" no monitor iniciará a desmontagem no endereço 0.
O montador é mínimo, mas funciona muito bem. Digite "a" para iniciar a montagem no endereço 0. As convenções são:
- Se uma linha começa não começa com um espaço em branco, ela deve começar com uma definição de rótulo. Os rótulos devem começar com um caractere alfabético seguido por caracteres alfanuméricos, podem ter no máximo 3 caracteres e diferenciam maiúsculas de minúsculas.
- Após o primeiro espaço em branco em uma linha, o montador espera um mnemônico (LDA, STA, OUT ...).
- O mnemônico especial ".BY" especifica diretamente um byte de dados a ser armazenado no local atual.
- O mnemônico especial ".OR" diz ao montador para continuar montando em um novo endereço.
- Se um argumento começar com um caractere alfabético, será considerado um rótulo.
- Espera-se que qualquer argumento numérico seja um número decimal. Para especificar hexadecimal, preceda o argumento com um "$". Por exemplo, para carregar o número FF hexadecimal no registro A, use "LDA # $ FF".
- Qualquer coisa depois de um ";" é considerado um comentário e é ignorado.
Por exemplo, o código Fibonacci pode ser inserido da seguinte forma:
primeiro LDA # 0; x =0 STA x LDA # 1; y =1 STA y lp ADD x; z =y + x STA z JC primeiro; reinicie se overflow OUT; imprimir z LDA y; x =y STA x LDA z; y =z STA y JMP lp; loop x .BY 0 y .BY 0 z .BY 0
Quais são as limitações?
Para economizar espaço de RAM no Arduino, o montador funciona como um montador de 1 passagem (caso contrário, o Arduino teria que armazenar em buffer todo o código-fonte). O montador grava os opcodes na memória do computador breadboard à medida que são inseridos. Isso significa que a montagem é retardada pela velocidade do clock do computador protoboard. Se você copiar e colar texto na janela do terminal, isso pode levar à perda de caracteres, pois o Arduino não consegue acompanhar os caracteres que chegam a 9600 baud (porque está gastando muito tempo esperando pelo relógio do computador breadboard). Para contornar isso, reduza a taxa de transmissão ou use o TeraTerm, que fornece uma configuração para especificar um atraso entre os caracteres enviados. A outra solução alternativa é aumentar a velocidade do clock no computador protoboard. Meu clock vai até 160kHz e nessa velocidade posso copiar e colar código a 9600 baud sem problemas.
Em sua configuração padrão, o esboço do Arduino pode lidar com frequências de clock no computador breadboard de até cerca de 1-2kHz (talvez um pouco mais). Observe que o relógio de Ben em sua configuração padrão não vai mais rápido do que 500Hz. Se o seu relógio for mais rápido, procure o
#ifdef FAST_IO mudar no código. Ligar FAST_IO deve fazer o Arduino funcionar com velocidades de clock de até 250kHz. Eu testei até 160kHz. Provavelmente seria possível suportar velocidades mais altas implementando os loops de tempo crítico diretamente no assembler, mas honestamente, uma velocidade de clock de 160kHz já parece muito rápida no computador de placa de ensaio com suas capacidades limitadas de outra forma. Certifique-se de ler os comentários correspondentes no código antes de ativar FAST_IO. O Arduino tem 1k de EEPROM e, portanto, pode conter 1024/16 =64 programas diferentes. Na verdade, é 63, uma vez que 16 bytes são reservados para salvar os dados de configuração. Isso não é muito, mas provavelmente o suficiente para conter todos os programas que você pode criar. Apenas os programas de número 0-15 daqueles podem ser selecionados por meio dos interruptores dip (1-14 para inicialização automática), mas os comandos "s" e "l" funcionarão com a faixa completa 0-62.
Parece um pouco confuso. Você pode arrumar isso?
Sim! Na minha versão final aqui, na verdade, usei apenas o chip Atmega 328P (junto com um cristal de 16 MHz e capacitores) em vez de um Arduino UNO. O regulador de tensão no UNO não é necessário aqui, já que o Arduino está usando diretamente os 5V de nossa fonte de alimentação de qualquer maneira. A única perda é que agora temos que usar um conversor USB para serial separado (FTDI ou similar) para falar com o Atmega. A aparência geral disso se encaixa muito melhor com o resto do computador breadboard:
Outra otimização é remover o bootloader do Arduino / Atmega. Isso elimina o atraso de 2 segundos enquanto o bootloader do Arduino é inicializado. Vou postar instruções sobre como fazer isso se as pessoas estiverem interessadas. Deixe-me saber nos comentários!
Código
Programador de computador breadboard
O esboço do Arduino para o programador de computador breadboardhttps://github.com/dhansel/programmerEsquemas
drive_pD8k28E85v.fzzProcesso de manufatura