Aus einem Arduino Uno einen funktionierenden Computer machen

Gibt es Arduino-Enthusiasten da draußen?

Hey, ich habe darüber nachgedacht und je mehr ich darüber nachdenke, desto mehr denke ich, dass ich das tatsächlich tun kann. Meine Idee lautet im Grunde: Machen Sie aus einem Arduino Uno-Mikrocontroller einen funktionierenden Computer.

Mein einziges Ziel für diesen Computer ist die Möglichkeit, BASIC-Programme zu bearbeiten und auszuführen. Das ist alles. Ich möchte es nur für die Programmierung, da das ungefähr das einzige ist, woran ich gerade interessiert bin :)

So wie ich das sehe, benötige ich drei Haupthardwarekomponenten:

1. irgendeine Form einer Anzeige (VGA-Bildschirm oder so etwas)
2. eine Möglichkeit, Tastatureingaben zu registrieren, und
3. eine Möglichkeit, Daten im externen Speicher zu speichern.

Kennt jemand eine Möglichkeit, dies zu tun? Ich kenne Möglichkeiten zur Anzeige auf einem Bildschirm, kenne aber keine gute API / Hardwarekomponente zum Registrieren von Tastatureingaben oder zum Speichern von externem Speicher.

Ich werde dabei viel Hilfe brauchen. Kann mir jemand helfen und Ideen und nützliche Tipps und Vorschläge für gute Hardware / eine gute Open-Source-Bibliothek oder zwei, drei oder zehn anbieten?

Hinzugefügt:

Blog Erstellen eines Arduino Uno-Computers für alle Interessierten.

Die Tastatur kann einfach mit einer PS / 2-Tastatur erstellt werden - sie ist nur seriell und es gibt viele Tutorials dafür.

Das Speichern von Daten kann einfach auf einer SD-Karte erfolgen - dafür gibt es bereits einen Schutzschild.

Was das Video betrifft - das ist erheblich schwieriger. Wenn Sie beispielsweise möchten, dass der Arduino ein PAL-Videosignal erzeugt, ist Ihre Arbeit für Sie ausgeschnitten. Ja, es ist möglich, und jemand hat ein Arduino "Pong" -Spiel erstellt, aber es ist eine sehr klobige Grafik und nur Schwarzweiß.

Für VGA benötigen Sie eine Schnittstelle, um die Arbeit für Sie zu erledigen. Sparkfun verkaufte früher die Picaso-Grafikkarte , die für die Arbeit mit dem Arduino hergestellt werden konnte, aber leider wurde sie eingestellt und es gibt noch keine Pläne für einen Ersatz.

TBH Ihre beste Wette wäre, so etwas wie ein Wyse-Terminal zu verwenden und mit dem Arduino vollständig seriell zu kommunizieren. Viel einfacher als mit Videosignalen und so weiter zu spielen.

Ich sehe Olins Punkt hier - wenn Sie nur BASIC bearbeiten / ausführen / lernen möchten, verwenden Sie einfach einen PC.

Wenn das Ziel jedoch die Herausforderung ist, einen Computer zu erstellen, auf dem BASIC ausgeführt werden kann, und gleichzeitig mehr über die Hardware und die Implementierung auf niedrigerer Ebene zu erfahren, ist dies etwas anders. Ich bin alles für solche Dinge, es ist eine großartige Möglichkeit, das Wissen zu verbessern, und ich bin sicher, dass Sie viel davon haben werden. Wie Steven erwähnt, können alle verwirrenden und (meistens) irrelevanten Ebenen, die z. B. Windows hat, entfernt werden, wobei die grundlegenden Konzepte (kein Wortspiel beabsichtigt) erhalten bleiben.

Wie auch immer, Sie könnten für diese ein wenig mächtiger wie die PIC32 etwas sehen wollen, wie es mit allen Funktionen kann viel sein sollte (zB Grund VGA) auf seine eigene ist.
Hier ist eine Arduino-kompatible Karte , die UNO32.
Die Maximite ist ein Computer mit BASIC-Interpreter, der auf einer PIC32 basiert. Vielleicht möchten Sie sich das Design und die Konstruktion ansehen, um ein paar Ideen zu erhalten.

Sie haben Glück, weil ich gerade an einem Arduino-PC arbeite! Es ist aber nicht viel, nur das erste Modell. Die Firmware ist auch sehr einfach und hat einen kleinen API-Satz. Aber das Ding funktioniert! Nicht gut genug, um BASIC (oder eine andere Sprache als die eigene) zu bearbeiten, aber dies ist nur das erste Modell. Die Mobo ist ganz einfach, und ich dies . Hier ist die Firmware, die ich verwendet habe:

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

Die Methodenbeschreibung ist schwer zu erklären, aber der Code wird als Rohbyte gespeichert. Ich sollte bald Entwicklungssoftware haben ... Hoffe das hilft! Wenn Sie dies jemals für Projekte verwenden möchten, MÜSSEN SIE EINE BIOS.mk8-Datei im Stammverzeichnis der SD haben, sonst funktioniert das System nicht.

Bei allem Respekt vor David Brin (ich mag seine Bücher sehr; ich bin nicht qualifiziert zu beurteilen, wie gut er als Astrophysiker ist), ist er weder Programmierer noch Pädagoge.

Ich war in den Anfängen von PCs in der Nähe und habe programmiert, und ich habe eine ganze Menge BASIC-Code geschrieben. Und seitdem schreibe ich professionell Code.

Der Grund, warum wir damals BASIC verwendet haben, war, dass Ihre beiden Optionen darin bestanden, BASIC zu verwenden oder in Assembly zu schreiben, und Assembly war sowohl schwerer zu verstehen als auch viel umständlicher zu verwenden. So grundlegend.

In den mehr als 30 Jahren seitdem wurden die Programmieranweisungen erheblich verbessert. Meine Frau unterrichtet einen Programmierkurs für Anfänger, in dem Alice (www.alice.org) verwendet wird, und der konzeptionell weitaus besser ist als die älteren Ansätze.

Ich denke, Brins Lösung war ziemlich elegant. Sie könnten etwas ziemlich Einfaches auf einem Raspberry PI bauen. Auf dem Arduino wird es meiner Meinung nach schwierig sein, alles, was Sie brauchen, in 2 KB RAM zu stecken. Das muss das Betriebssystem / Monitor enthalten, das Sie am Ende schreiben, einen Befehlsinterpreter, Code für die Anzeige und Speicher für das Basisprogramm selbst.

Ganz zu schweigen von der Tatsache, dass Sie eine Menge schwieriger und benutzerdefinierter Programmierungen durchführen müssen, damit Sie Code in einer einfachen Umgebung schreiben können.

Ich verstehe es nicht Wenn Sie nur eine Möglichkeit zum Programmieren in Basic haben möchten, führen Sie einen Basisinterpreter auf Ihrem PC aus. Ich verstehe nicht, wie Sie erwarten, dass der Arduino dabei hilft. Der Arduino ist ein Mikrocontroller mit viel ausgefallener Software, um die Hardwaredetails zu verbergen. Ein Teil der Kosten hierfür ist eine geringere Leistung und ein höherer Ressourcenverbrauch als das entsprechende Programm, das direkt auf dem bloßen Mikrocontroller ausgeführt wird. Jetzt möchten Sie Arduino-Code schreiben, um ihn wieder in einen Universalcomputer umzuwandeln, damit Sie wiederum einen Basic-Interpreter auf diesem Universalcomputer ausführen können? Das macht wenig Sinn.

Da Ihr einziges Ziel darin besteht, Basic-Programme bearbeiten und ausführen zu können (einen Basic-Interpreter ausführen), beginnen Sie zunächst mit einer allgemeineren Computerplattform, vorzugsweise sogar einer, für die bereits ein Basic-Interpreter verfügbar ist. Ihr PC ist genau eine solche Plattform. Wenn Sie möchten, dass dies externe Hardware ist, klingt es so, als würde ein Standard-Einplatinencomputer Ihre Anforderungen viel besser erfüllen als ein Arduino.

Hinzugefügt:

Sie sagen jetzt, dass Sie nicht auf einem PC ausgeführt werden möchten, und stellen diesen Link auf jemanden, von dem die Befehlszeile Basic für sein Kind lernen soll. Zugegeben, ich habe nicht den ganzen Artikel gelesen (ich mag es nicht, wenn Leute mit Links antworten. Sie sollten in der Lage sein, Ihren Standpunkt in wenigen Sätzen unabhängig zu formulieren), aber ich sehe nicht, wie ein PC einen Befehlszeilen-Basic-Interpreter ausführt geht Ihr Problem nicht an. Warum darf der Basic-Interpreter nicht auf einem PC ausgeführt werden, aber auf einem Arduino? Denken Sie daran, Sie haben vorab gesagt, dass Ihr einziges Ziel darin bestand, Basisprogramme zu bearbeiten und auszuführen. Nichts in dieser Aussage sagt aus, auf welcher Hardware es ausgeführt werden muss, und keine Ihrer nachfolgenden Erklärungen erklärt, warum ein PC nicht gut funktioniert.

Es gibt wahrscheinlich Basic-Interpreter, die in der Befehlszeile ausgeführt werden. Das alte QBASIC funktioniert möglicherweise noch in einem DOS-Kompatibilitätsmodus. Auch wenn dies nicht der Fall ist, da Sie bereit sind, Hardware dafür bereitzustellen, wie kann DOS und QBASIC auf einem PC nicht das liefern, wonach Sie gefragt haben?

Liste der AVR BASIC-Dolmetscher:

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

Ich mag die Idee, eine gängige App wie BASIC auf einem Arduino auszuführen, besonders wenn Sie sie selbst von Hand erstellt haben. Ich mag die Bequemlichkeit, ein handliches, batteriebetriebenes Arduino-Gerät zu haben, auf dem die gewünschte App ausgeführt wird. Wenn ich es wäre, würde ich vielleicht ein Arduino MEGA verwenden, damit ich genug Stifte für die Tastatur und ein SD-Schild zur Aufbewahrung hätte.

Ich würde ein Farbgrafik-LCD oder einen TFT-Bildschirm anstelle von VGA wählen, um die Programmierung und die Verbindungen zu vereinfachen, um Datum und Uhrzeit (RTC) zu verfolgen, und was ist eine App ohne Internet oder Netzwerk (Ethernet Shield)? Zusätzliche I2C-RAMs (24LC256) vielleicht? Und ein paar I2C MCP223017 für den Fall, dass ich ein paar zusätzliche Ports benötige. Wie wäre es mit mehreren Arduinos, die eine parallele Aufgabe erledigen? Das würde die Leistung verbessern, da bin ich mir sicher.