Criando um computador funcional com um Arduino Uno

Algum entusiasta do Arduino por aí?

Ei, eu tenho pensado sobre isso e quanto mais eu penso sobre isso, mais eu acho que posso realmente fazer isso. Minha idéia é basicamente a seguinte: Crie um computador funcional com um microcontrolador Arduino Uno.

Meu único objetivo neste computador é a capacidade de editar e executar programas BASIC. Isso é tudo. Eu só quero isso para a programação, pois é a única coisa que me interessa no momento :)

Então, da maneira como vejo, precisarei de três componentes principais de hardware:

1. alguma forma de exibição (tela VGA ou algo assim)
2. alguma maneira de registrar a entrada do teclado e
3. alguma maneira de armazenar dados na memória externa.

Alguém sabe de alguma maneira de fazer isso? Conheço maneiras de exibir em uma tela, mas não conheço um bom componente de API / hardware para registrar a entrada do teclado ou para armazenar memória externa.

Vou precisar de muita ajuda nisso. Alguém pode me ajudar e oferecer idéias, dicas e sugestões úteis para um bom hardware / uma boa biblioteca de código aberto, ou duas, três ou dez?

Adicionado:

Blog Criando um computador Arduino Uno para quem estiver interessado.

O teclado pode ser feito simplesmente usando um teclado PS / 2 - é apenas serial e há muitos tutoriais por aí.

O armazenamento de dados pode ser feito simplesmente em um cartão SD - já existe um escudo para isso.

Quanto ao vídeo - isso é consideravelmente mais difícil. Se você deseja que o Arduino gere um sinal de vídeo PAL, por exemplo, você terá seu trabalho preparado para você. Sim, é possível, e alguém criou um jogo "pong" do Arduino, mas é um gráfico muito robusto e somente em preto e branco.

Para o VGA, você precisará de algum tipo de interface para fazer o trabalho para você. O Sparkfun costumava vender a placa de vídeo do Picaso que poderia ser feita para funcionar com o Arduino, mas infelizmente isso foi descontinuado e ainda não há planos de substituição.

TBH, sua melhor aposta seria usar algo como um terminal Wyse e se comunicar com o Arduino completamente usando serial. Muito mais simples do que mexer com sinais de vídeo e tal.

Entendo o ponto de vista de Olin aqui - se você apenas deseja editar / executar / aprender o BASIC, basta usar um PC.

No entanto, se o objetivo for o desafio de criar um computador que possa executar o BASIC e aprender sobre o hardware e a implementação de nível inferior ao mesmo tempo, isso será um pouco diferente. Sou a favor de coisas como essa, é uma ótima maneira de melhorar o conhecimento e tenho certeza de que você obterá muito disso. Como Steven menciona todas as camadas confusas e (principalmente) irrelevantes que o Windows possui podem ser removidas, deixando os conceitos básicos (sem trocadilhos).

De qualquer forma, você pode querer olhar para algo um pouco mais poderosa como o PIC32 para isso, como deveria ser muito capaz com todas as funcionalidades (por exemplo básica VGA), por si própria.
Aqui está uma placa compatível com Arduino, o UNO32
O Maximite é um computador com intérprete BASIC baseado em um PIC32; você pode querer dar uma olhada no Design e na Construção para obter algumas idéias.

Você está com sorte, mais ou menos, porque atualmente estou trabalhando em um PC com arduino! Não é muito, apenas o primeiro modelo. O firmware também é muito simples e possui um pequeno conjunto de APIs. Mas, a coisa funciona! Não é bom o suficiente para editar o BASIC (ou qualquer outro idioma, exceto o próprio), mas este é apenas o primeiro modelo. O mobo é bastante simples, e eu usei isso . Aqui está o firmware que eu usei:

        #include <LCD4884.h>
#include <SD.h>
#include <SPI.h>
#include <SoftwareSerial.h>

void setup() {   
    lcd.LCD_init();             
    lcd.LCD_clear();
    lcd.LCD_write_string_big(0, 0, "Gilbert", MENU_NORMAL);
    pinMode(10, OUTPUT);
    delay(3000);
}

byte line = 10;
SoftwareSerial FC(8,9);
byte RAM[501];
byte Error = 0;
char tempString[15];

void loop() {
    // <editor-fold defaultstate="collapsed" desc="Initilization">
    FC.begin(4800);
    if (!FC.available()) {
        lcd.LCD_clear();
        lcd.LCD_write_string(0, 0, "FC Failed!", MENU_NORMAL);
        delay(1000);
    }
    int address = 1;
    lcd.LCD_clear();
    lcd.LCD_write_string(0, 0, "SD Init...", MENU_NORMAL);
    if (!SD.begin(10)) {
        lcd.LCD_clear();
        lcd.LCD_write_string(0, 0, "SD Failed!", MENU_NORMAL);
        while (true) {
            ;
        }
    }
    lcd.LCD_clear();
    lcd.LCD_write_string(0, 0, "Loading...", MENU_NORMAL);
    File file;
    file = SD.open("BIOS.mk8", FILE_READ);
    RAM[0] = 53;
    RAM[file.read()] = 8;
    while (file.available()) {
        RAM[address] = file.read();
        address++;
    }
    address++;
    RAM[address] = 55;
    long loops = 0;
    long time1 = 0;
    long time2 = 0;
    address = 0;
    byte instruction = 0;
    int exeaddress;
    byte tempbyte;
    lcd.LCD_clear();
    lcd.LCD_write_string(0, 0, "EMU. Started", MENU_NORMAL);// </editor-fold>
    //emulation loop
    while(true){
        switch(RAM[address]){
            // <editor-fold defaultstate="collapsed" desc="Codes 1-10">
            case 1:
            {//getCycleCount[intvar i]
                tempbyte = (loops) / ((time2 - time1) / 1000);
                convert(address + 1);
                writeInt(exeaddress, tempbyte);
                break;
            }
            case 2:
            {//getTemp[intvar i]
                tempbyte = (((analogRead(A1) / 1024.0) * 5.0) - .5) * 100;
                convert(address + 1);
                writeInt(exeaddress, tempbyte);
                break;
            }
            case 3:
            {//getKey[intvar i]
                //Up 745
                //Down 332
                //Left 0
                //Right 509
                //Center 145
                switch (analogRead(A0)) {
                    case 745:
                    {
                        tempbyte = 1;
                        break;
                    }
                    case 332:
                    {
                        tempbyte = 2;
                        break;
                    }
                    case 0:
                    {
                        tempbyte = 3;
                        break;
                    }
                    case 509:
                    {
                        tempbyte = 4;
                        break;
                    }
                    case 145:
                    {
                        tempbyte = 5;
                        break;
                    }
                }
                convert(address + 1);
                writeInt(exeaddress, tempbyte);
                break;
            }
            case 4:
            {//printLine[variable v]
                if (line > 70) {
                    lcd.LCD_clear();
                    line = 0;
                }
                switch(RAM[address + 1]){
                    case 9:{
                        tempbyte = RAM[address + 1];
                        tempString[0] = char(tempbyte);
                        break;
                    }
                    case 15:{
                        convert(address + 1);
                        break;
                    }
                }
                lcd.LCD_write_string(0, line, tempString, MENU_NORMAL);
                line += 10;
                break;
            }
            case 5:
            {//exe detector
                exeaddress = address;
                break;
            }
            case 7:
            {//lcdClear
                lcd.LCD_clear();
                line = 0;
                break;
            }
            case 10:
            {//declareInteger[string name]
                convert(address + 1);
                tempbyte = 0;
                while (tempbyte != 15) {
                    RAM[address + tempbyte + 1] = tempString[tempbyte];
                }
                break;
            }// </editor-fold>
            case 11:{//getError[intvar i]
                tempbyte = Error;
                Error = 0;
                convert(address + 1);
                writeInt(exeaddress, tempbyte);
                break;
            }
            case 12:{//deadlock
                while(true){;}
                break;
            }
            case 13:{//assignInteger[int value, intvar i]
                tempbyte = RAM[address + 1];
                convert(address + 2);
                writeInt(exeaddress, tempbyte);
                break;
            }
            case 14:{//transferInteger[intvar i1, intvar i2]
                convert(address + 1);
                writeInt(exeaddress, RAM[getIntAddr(exeaddress)]);
                break;
            }
        }
        // <editor-fold defaultstate="collapsed" desc="post loop process">
        address++;
        time2 = millis();
        loops++;
        if (loops < 0) {
            loops = 0;
        }// </editor-fold>
    }
}

void convert(int startAddress){
    byte charadd = 0;
    while(RAM[startAddress] != 6){
        tempString[charadd] = RAM[startAddress];
        charadd++;
        startAddress++;
    }
}

void writeInt(int exeStart, byte value){
    byte count = 0;
    char compare[15];
    while(true){
        if (RAM[exeStart] == 9) {
            exeStart++;
            while (count != 15) {
                compare[count] = RAM[exeStart];
                exeStart++;
                count++;
            }
            if(compare == tempString){
                RAM[exeStart + 2] = value;
                break;
            }else{
                exeStart += 3;
            }
            if(RAM[exeStart] == 8){
                Error = 1;
            }
        }
    }
}

int getIntAddr(int exeStart){
    byte count = 0;
    char compare[15];
    while(true){
        if (RAM[exeStart] == 9) {
            exeStart++;
            while (count != 15) {
                compare[count] = RAM[exeStart];
                exeStart++;
                count++;
            }
            if(compare == tempString){
                return RAM[exeStart + 2];
                break;
            }else{
                exeStart += 3;
            }
            if(RAM[exeStart] == 8){
                Error = 1;
            }
        }
    }
}

A descrição do método é difícil de explicar, mas o código é armazenado como bytes brutos. Eu deveria ter o software de desenvolvimento em breve ... Espero que ajude! Se você quiser usá-lo para qualquer projeto, DEVE TER UM arquivo BIOS.mk8 no diretório raiz do SD ou o sistema não funcionará.

Com todo o respeito a David Brin (eu gosto muito de seus livros; não sou qualificado para julgar o quão bom ele é como astrofísico), ele não é um programador nem um educador.

Eu estava por perto e codificando nos primeiros dias dos PCs e escrevi uma boa quantidade de código BASIC. E eu tenho escrito código profissionalmente desde então.

O motivo pelo qual usamos o BASIC naquela época era que suas duas opções eram usar o BASIC ou escrever na montagem, e a montagem era mais difícil de entender e muito mais difícil de usar. Tão básico.

Nos mais de 30 anos desde então, houve melhorias significativas nas instruções de programação. Minha esposa dá uma aula inicial de programação que usa Alice (www.alice.org), e é muito melhor conceitualmente do que as abordagens mais antigas.

Eu acho que a solução de Brin foi bastante elegante. Você pode criar algo bem simples em um PI de framboesa. No arduino, acho que será um desafio colocar tudo o que você precisa em 2K de RAM; que tem de conter qualquer OS / Monitor que você escreva, um interpretador de comandos, código para exibir e armazenamento do programa básico em si.

Sem mencionar o fato de que você terá que fazer muita programação difícil e personalizada para poder escrever código em um ambiente simples.

Eu não entendo. Se você deseja apenas meios de programar no Basic, execute um intérprete básico no seu PC. Não entendo como você espera que o Arduino ajude com isso. O Arduino é um microcontrolador com muitos softwares sofisticados para ocultar os detalhes do hardware. Parte do custo disso é menor desempenho e mais uso de recursos do que o programa equivalente sendo executado diretamente no microcontrolador simples. Agora você deseja escrever o código do Arduino para transformá-lo novamente em um computador de uso geral, tudo para que você possa executar um intérprete básico nesse computador de uso geral? Isso faz pouco sentido.

Como seu único objetivo é poder editar e executar programas Básicos (executar um intérprete Básico), comece com uma plataforma de computação de propósito mais geral em primeiro lugar, preferencialmente mesmo uma que já tenha um intérprete Básico disponível. Seu PC é exatamente essa plataforma. Se você deseja que esse seja um hardware externo, parece que um computador de placa única pronto para atender às suas necessidades seria muito melhor do que um Arduino.

Adicionado:

Agora você diz que não quer rodar em um PC e localiza este link sobre alguém que quer a linha de comando Basic para o filho aprender. É certo que não li o artigo inteiro (não gosto de pessoas respondendo com links. Você deve ser capaz de expressar seu argumento de forma independente em algumas frases), mas não vejo como um PC executando um interpretador básico de linha de comando não resolve o seu problema. Por que o intérprete Básico não tem permissão para executar em um PC, mas não há problema em executar em um Arduino? Lembre-se, você disse antecipadamente que seu único objetivo era editar e executar programas básicos. Nada nesta declaração diz em que hardware ele deve ser executado, e nenhuma das explicações subsequentes explica por que um PC não funcionaria bem.

Provavelmente existem intérpretes básicos que são executados na linha de comando. O antigo QBASIC ainda pode funcionar em algum modo de compatibilidade do DOS. Mesmo se não, como você está disposto a dedicar hardware a isso, como a execução do DOS e QBASIC em um PC não fornece o que você solicitou?

Lista de intérpretes do AVR BASIC:

1. http://jcwolfram.de/projekte/avr/chipbasic2/examples.php
2. http://www.avrfreaks.net/index.php?module=Freaks%20Academy&func=viewItem&item_id=688&item_type=project
3. http://www.cqham.ru/tbcgroup/index_eng.htm
4. http://cappels.org/dproj/Home.htm

Eu gosto da ideia de executar um aplicativo comum, como o BASIC em um Arduino, especialmente se você o tiver construído manualmente. Gosto da conveniência de ter um dispositivo Arduino prático, alimentado por bateria, executando o aplicativo que eu queria. Se fosse eu, usaria talvez um MEGA do Arduino para ter pinos suficientes para o teclado e um escudo SD para armazenamento.

Eu escolheria um LCD gráfico colorido ou uma tela TFT sobre VGA para simplificar a programação e as conexões, uma maneira de acompanhar a data e a hora (RTC) e o que é um aplicativo sem Internet ou rede (blindagem Ethernet)? RAMs I2C extras (24LC256) talvez? E alguns I2C MCP223017 para o caso de eu precisar de algumas portas extras. Que tal múltiplos Arduino fazendo uma tarefa paralela? Isso melhoraria o desempenho, tenho certeza.