Cómo hacer que una computadora funcional salga de un Arduino Uno

El teclado se puede hacer simplemente usando un teclado PS / 2, es solo un modelo en serie, y hay muchos tutoriales disponibles para él.

El almacenamiento de datos se puede hacer simplemente en una tarjeta SD; ya hay un protector para hacer eso.

En cuanto al video, eso es considerablemente más difícil. Si quieres que Arduino genere una señal de video PAL, por ejemplo, tienes tu trabajo hecho para ti. Sí, es posible, y alguien ha creado un juego "pong" de Arduino, pero son gráficos muy gruesos y solo en blanco y negro.

Para VGA, necesitará algún tipo de interfaz para hacer el trabajo por usted. Sparkfun solía vender la tarjeta de video de Picaso que podría funcionar para trabajar con el Arduino, pero desgraciadamente, se ha suspendido y ya está Aún no hay planes para un reemplazo.

TBH lo mejor sería usar algo como un terminal de Wyse y comunicarse con Arduino por completo usando serial. Mucho más simple que jugar con señales de video y demás.

Veo el punto de Olin aquí: si solo desea editar / ejecutar / aprender BASIC, simplemente use una PC.

Sin embargo, si el objetivo es el desafío de crear una computadora que pueda ejecutar BASIC y aprender sobre el hardware y la implementación de nivel inferior al mismo tiempo, entonces esto es un poco diferente. Estoy a favor de este tipo de cosas, es una excelente manera de mejorar el conocimiento y estoy seguro de que obtendrás mucho de ello. Como Steven menciona todas las capas confusas y (en su mayoría) irrelevantes que, por ejemplo, Windows se puede quitar, dejando los conceptos básicos (sin intenciones de palabra).

De todos modos, quizás quiera ver algo un poco más poderoso como el PIC32 para esto, ya que debería poder manejar toda la funcionalidad (por ejemplo, VGA básico) por sí mismo. < br> Aquí hay una placa compatible con Arduino, la UNO32
La Maximite es una computadora con un intérprete BÁSICO basado en un PIC32, es posible que desee ver la Diseño y construcción para algunas ideas.

Tienes suerte, porque estoy trabajando en una arduino PC ahora mismo. Pero no es mucho, solo el primer modelo. El firmware también es muy simple, y tiene un pequeño conjunto de API. Pero, ¡la cosa funciona! No es lo suficientemente bueno para editar BÁSICO (o cualquier idioma excepto el suyo propio), pero este es solo el primer modelo. El mobo es bastante simple, y usé this . Aquí está el firmware que utilicé:

        #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 descripción del método es difícil de explicar, pero el código se almacena como bytes sin procesar. Debería tener software de desarrollo pronto ... ¡Espero que esto ayude! Si alguna vez desea utilizar esto para cualquier proyecto, DEBE TENER UN BIOS.mk8 en el directorio raíz de la SD o el sistema no funcionará.

Con el debido respeto a David Brin (me gustan mucho sus libros; no estoy calificado para juzgar lo bueno que es como astrofísico), no es un programador ni un educador.

Estuve cerca y programando en los primeros días de las PC, y escribí una buena cantidad de código BÁSICO. Y he estado escribiendo código profesionalmente desde entonces.

La razón por la que usamos BASIC en ese entonces era que sus dos opciones eran usar BASIC o escribir en ensamblaje, y el ensamblaje era más difícil de entender y mucho más incómodo de usar. Tan basico.

En los más de 30 años desde entonces, ha habido mejoras significativas en la instrucción de programación. Mi esposa enseña una clase de programación para principiantes que usa Alice (www.alice.org), y es mucho mejor conceptualmente que los enfoques anteriores.

Creo que la solución de Brin fue bastante elegante. Podrías construir algo bastante simple en un Raspberry PI. En el arduino, creo que será un desafío meter todo lo que necesitas en 2K de RAM; que debe contener cualquier OS / Monitor que termine de escribir, un interpretador de comandos, un código para hacer la visualización y el almacenamiento del programa básico en sí.

Sin mencionar el hecho de que tendrá que hacer un montón de programación difícil y personalizada para poder escribir código en un entorno simple.

No lo entiendo. Si solo desea tener un medio para programar en Basic, ejecute un intérprete básico en su PC. No entiendo cómo esperas que Arduino ayude con esto. El Arduino es un microcontrolador con una gran cantidad de software sofisticado para ocultar los detalles del hardware. Parte del costo de esto es un menor rendimiento y más uso de recursos que el programa equivalente que se ejecuta directamente en el microcontrolador. ¿Ahora desea escribir el código Arduino para convertirlo de nuevo en una computadora de propósito más general, para que a su vez pueda ejecutar un intérprete básico en esa computadora de propósito general? Esto tiene poco sentido.

Dado que su único objetivo es poder editar y ejecutar programas básicos (ejecutar un intérprete básico), comience con una plataforma informática de propósito más general en primer lugar, de preferencia incluso uno que ya tenga un intérprete básico disponible. Tu PC es exactamente tal plataforma. Si desea que esto sea un hardware externo, parece que una computadora de una sola placa que esté disponible en el mercado satisfaría sus necesidades mucho mejor que un Arduino.

Añadido:

Ahora dice que no quiere correr en una PC y busque en este enlace a alguien que desea la línea de comandos Básico para que su hijo aprenda. Es cierto que no leí el artículo completo (no me gustan las personas que responden con enlaces. Debería poder expresar su punto de manera independiente en unas pocas frases), pero no veo cómo una PC ejecuta una línea de comandos. Intérprete básico no aborda su problema ¿Por qué no se permite que el intérprete básico se ejecute en una PC, pero está bien ejecutarlo en un Arduino? Recuerde, usted dijo por adelantado que su único objetivo era editar y ejecutar programas básicos. Nada en esa declaración dice en qué hardware se debe ejecutar, y ninguna de sus explicaciones posteriores explica por qué una PC no funcionaría bien.

Probablemente hay intérpretes básicos que se ejecutan en la línea de comandos. El antiguo QBASIC todavía podría funcionar en algún modo de compatibilidad con DOS. Incluso si no, ya que está dispuesto a dedicar hardware a esto, ¿cómo es que ejecutar DOS y QBASIC en una PC no proporciona lo que pidió?

Lista de intérpretes AVR BASIC:

1. enlace
2. enlace
3. enlace
4. enlace

Me gusta la idea de ejecutar una aplicación común, como BASIC en un Arduino, especialmente si la construyes tú mismo a mano. Me gusta la comodidad de tener un dispositivo Arduino que funciona con batería y que ejecuta la aplicación que quería. Si fuera yo, usaría quizás un Arduino MEGA para tener suficientes pines para el teclado y un escudo SD para el almacenamiento.

Elegiría una pantalla LCD con gráficos en color o una pantalla TFT sobre VGA para simplificar la programación y las conexiones, una forma de llevar un registro de la fecha y la hora (RTC), y ¿qué es una aplicación sin Internet o sin conexión a redes (escudo Ethernet)? ¿RAM extra I2C (24LC256) tal vez? Y algunos I2C MCP223017 solo en caso de que necesite algunos puertos adicionales. ¿Qué tal si varios Arduino hacen una tarea paralela? Eso mejoraría el rendimiento, estoy seguro.