Realizzare un computer funzionale da un Arduino Uno

Qualche appassionato di Arduino là fuori?

Ehi, ci ho pensato e più ci penso, più penso di poterlo fare davvero. La mia idea è sostanzialmente questa: realizzare un computer funzionale con un microcontrollore Arduino Uno.

Il mio unico obiettivo per questo computer è la possibilità di modificare ed eseguire programmi BASIC. È tutto. Lo voglio solo per la programmazione, dato che è praticamente l'unica cosa che mi interessa in questo momento :)

Quindi, per come la vedo, avrò bisogno di tre componenti hardware principali:

1. qualche forma di un display (schermo VGA o qualcosa del genere)
2. un modo per registrare l'input da tastiera e
3. un modo per archiviare i dati nella memoria esterna.

Qualcuno sa come fare? Conosco i modi per visualizzare uno schermo, ma non conosco un buon componente API / hardware per registrare l'input da tastiera o archiviare memoria esterna.

Avrò bisogno di molto aiuto su questo. Qualcuno può darmi una mano e offrire idee e suggerimenti utili e suggerimenti per un buon hardware / una buona libreria open source, o due, tre o dieci?

Inserito il:

Blog Creazione di un computer Arduino Uno per chiunque sia interessato.

La tastiera può essere fatta semplicemente usando una tastiera PS / 2: è solo seriale e ci sono molti tutorial là fuori per questo.

La memorizzazione dei dati può essere eseguita semplicemente su una scheda SD: esiste già uno scudo per farlo.

Per quanto riguarda il video, è molto più difficile. Se vuoi che Arduino generi un segnale video PAL, ad esempio, hai il tuo lavoro tagliato per te. Sì, è possibile e qualcuno ha creato un gioco "pong" di Arduino, ma è una grafica molto spessa e solo in bianco e nero.

Per VGA avrai bisogno di una qualche forma di interfaccia per fare il lavoro per te. Sparkfun vendeva la scheda video Picaso che poteva essere utilizzata per funzionare con Arduino, ma purtroppo è stata interrotta e non ci sono ancora piani per una sostituzione.

TBH la soluzione migliore sarebbe quella di utilizzare qualcosa come un terminale Wyse e comunicare completamente con l'Arduino tramite seriale. Molto più semplice che pasticciare con segnali video e simili.

Vedo il punto di Olin qui - se vuoi solo modificare / eseguire / imparare BASIC usa semplicemente un PC.

Tuttavia, se l'obiettivo è la sfida di creare un computer in grado di eseguire BASIC e conoscere contemporaneamente l'hardware e l'implementazione di livello inferiore, allora questo è un po 'diverso. Sono tutto per cose come questa, è un ottimo modo per migliorare la conoscenza e sono sicuro che ne otterrai molto. Poiché Steven menziona tutti i livelli confusi e (per lo più) irrilevanti che, ad esempio, Windows, possono essere rimossi, lasciando i concetti di base (non intesi come giochi di parole).

Ad ogni modo, potresti voler guardare qualcosa di un po 'più potente come il PIC32 per questo, poiché dovrebbe essere in grado di gestire da solo tutte le funzionalità (ad esempio VGA di base).
Ecco una scheda compatibile con Arduino, UNO32
The Maximite è un computer con interprete BASIC basato su un PIC32, ti consigliamo di dare un'occhiata a Design and Construction per alcune idee.

Sei fortunato, in un certo senso, perché sto attualmente lavorando su un PC Arduino! Non è molto però, solo il primo modello. Anche il firmware è molto semplice e ha un piccolo set di API. Ma la cosa funziona! Non abbastanza buono per modificare BASIC (o qualsiasi lingua tranne la propria), ma questo è solo il primo modello. La mobo è abbastanza semplice, e ho usato questo . Ecco il firmware che ho usato:

        #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;
            }
        }
    }
}

La descrizione del metodo è difficile da spiegare, ma il codice viene archiviato come byte non elaborati. Dovrei avere presto il software di sviluppo ... Spero che questo aiuti! Se vuoi usarlo per qualsiasi progetto, DEVI AVERE un file BIOS.mk8 nella directory principale della SD o il sistema non funzionerà.

Con tutto il rispetto per David Brin (mi capita di apprezzare molto i suoi libri; non sono qualificato per giudicare quanto sia bravo come astrofisico), non è né un programmatore né un educatore.

Ero nei paraggi e scrivevo codice ai primi tempi dei PC e ho scritto una buona quantità di codice BASIC. E da allora scrivo codice professionale.

La ragione per cui abbiamo usato BASIC all'epoca era che le tue due opzioni erano usare BASIC o scrivere in assembly, e assembly era più difficile da capire e molto più ingombrante da usare. Quindi, BASIC.

Negli ultimi 30 anni, ci sono stati miglioramenti significativi nelle istruzioni di programmazione. Mia moglie insegna una lezione di programmazione iniziale che utilizza Alice (www.alice.org), ed è molto meglio concettualmente degli approcci più vecchi.

Penso che la soluzione di Brin sia stata piuttosto elegante. Potresti costruire qualcosa di piuttosto semplice su un Raspberry PI. Sull'arduino, penso che sarà difficile riempire tutto ciò di cui hai bisogno in 2K di RAM; che deve contenere qualsiasi sistema operativo / monitor che si finisce per scrivere, un interprete di comandi, un codice per eseguire la visualizzazione e l'archiviazione per il programma di base stesso.

Per non parlare del fatto che dovrai fare molte programmazioni difficili e personalizzate in modo da poter scrivere codice in un ambiente semplice.

Non capisco Se vuoi solo avere un mezzo per programmare in Basic, esegui un interprete di base sul tuo PC. Non capisco come ti aspetti che Arduino ti aiuti. Arduino è un microcontrollore con un sacco di software sofisticato per nascondere i dettagli hardware. Parte del costo è rappresentato da prestazioni inferiori e maggiore utilizzo delle risorse rispetto al programma equivalente in esecuzione direttamente sul microcontrollore nudo. Ora vuoi scrivere il codice Arduino per trasformarlo in un computer più generico, tutto in modo da poter eseguire a sua volta un interprete Basic su quel computer generico? Questo ha poco senso.

Poiché il tuo unico obiettivo è quello di essere in grado di modificare ed eseguire i programmi Basic (eseguire un interprete Basic), inizia innanzitutto con una piattaforma di elaborazione più generica, preferibilmente anche uno che abbia già un interprete Basic disponibile. Il tuo PC è esattamente una piattaforma del genere. Se vuoi che questo sia un hardware esterno, sembra che un computer su scheda singola standard soddisfi le tue esigenze molto meglio di un Arduino.

Inserito il:

Ora dici che non vuoi correre su un PC e sito questo link su qualcuno che desidera la riga di comando di base da cui suo figlio può imparare. Devo ammettere che non ho letto l'intero articolo (non mi piace che le persone rispondano con i link. Dovresti essere in grado di affermare il tuo punto in modo indipendente in poche frasi), ma non vedo come un PC che esegue un interprete di base da riga di comando non risolve il tuo problema. Perché l'interprete Basic non può essere eseguito su un PC, ma è OK eseguire su un Arduino? Ricorda, hai detto in anticipo che il tuo unico obiettivo era modificare ed eseguire i programmi di base. Nulla in quella dichiarazione dice su quale hardware debba funzionare, e nessuna delle tue spiegazioni successive spiega perché un PC non vada bene.

Probabilmente ci sono interpreti di base che vengono eseguiti sulla riga di comando. Il vecchio QBASIC potrebbe ancora funzionare in alcune modalità di compatibilità DOS. Anche se, dato che sei disposto a dedicare hardware a questo, in che modo eseguire DOS e QBASIC su un PC non fornisce ciò che hai richiesto?

Elenco degli interpreti 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

Mi piace l'idea di eseguire un'app comune, come BASIC su un Arduino, specialmente se l'hai costruita tu stesso. Mi piace la comodità di avere un pratico dispositivo Arduino a batteria che esegue l'app che desideravo. Se fossi in me userei forse un Arduino MEGA, quindi avrei abbastanza pin per la tastiera e uno scudo SD per l'archiviazione.

Sceglierei un display LCD a colori o uno schermo TFT su VGA per semplicità di programmazione e connessioni, un modo per tenere traccia di data e ora (RTC) e cos'è un'app senza Internet o rete (Ethernet Shield)? RAM I2C extra (24LC256) forse? E alcuni I2C MCP223017 nel caso avessi bisogno di alcune porte extra. Che ne dici di più Arduino sta facendo un'attività parallela? Ciò migliorerebbe le prestazioni, ne sono sicuro.