Faire un ordinateur fonctionnel à partir d'un Arduino Uno

Des amateurs d'Arduino là-bas?

Hé, j'y ai pensé et plus j'y pense, plus je pense que je peux vraiment faire ça. Mon idée est essentiellement la suivante: fabriquer un ordinateur fonctionnel à partir d'un microcontrôleur Arduino Uno.

Mon seul objectif pour cet ordinateur est de pouvoir éditer et exécuter des programmes BASIC. C'est tout. Je ne le veux que pour la programmation, car c'est à peu près la seule chose qui m'intéresse en ce moment :)

Donc, d'après ce que je vois, j'ai besoin de trois composants matériels principaux:

1. une forme d'affichage (écran VGA ou autre)
2. un moyen d'enregistrer l'entrée du clavier, et
3. un moyen de stocker des données dans la mémoire externe.

Quelqu'un connaît-il un moyen de le faire? Je connais des façons d'afficher sur un écran, mais je ne connais pas un bon composant API / matériel pour enregistrer les entrées au clavier ou pour stocker la mémoire externe.

Je vais avoir besoin de beaucoup d'aide à ce sujet. Quelqu'un peut-il m'aider et offrir des idées et des conseils et suggestions utiles pour un bon matériel / une bonne bibliothèque open source, ou deux, ou trois, ou dix?

Ajoutée:

Blog Créer un ordinateur Arduino Uno pour tous ceux qui sont intéressés.

Le clavier peut être fait simplement en utilisant un clavier PS / 2 - c'est juste en série, et il y a beaucoup de tutoriels là-bas.

Le stockage des données peut se faire simplement sur une carte SD - il existe déjà un bouclier pour le faire.

Quant à la vidéo - c'est beaucoup plus difficile. Si vous voulez que l'Arduino génère un signal vidéo PAL par exemple, vous avez du pain sur la planche. Oui, c'est possible, et quelqu'un a créé un jeu Arduino "pong", mais c'est des graphismes très volumineux et uniquement en noir et blanc.

Pour VGA, vous aurez besoin d'une certaine forme d'interface pour faire le travail pour vous. Sparkfun vendait la carte vidéo Picaso qui pourrait être conçue pour fonctionner avec l'Arduino, mais hélas, elle a été abandonnée et il n'y a pas encore de plan de remplacement.

TBH votre meilleur pari serait d'utiliser quelque chose comme un terminal Wyse et de communiquer complètement avec l'Arduino en série. Beaucoup plus simple que de jouer avec des signaux vidéo et autres.

Je vois le point d'Olin ici - si vous voulez seulement éditer / exécuter / apprendre BASIC, utilisez simplement un PC.

Cependant, si l'objectif est le défi de créer un ordinateur qui peut exécuter BASIC et en savoir plus sur le matériel et la mise en œuvre de niveau inférieur en même temps, c'est un peu différent. Je suis tout pour des trucs comme ça, c'est un excellent moyen d'améliorer les connaissances et je suis sûr que vous en tirerez beaucoup. Comme Steven mentionne toutes les couches déroutantes et (principalement) non pertinentes que, par exemple, Windows peut supprimer, laissant les concepts de base (sans jeu de mots).

Quoi qu'il en soit, vous voudrez peut -être regarder quelque chose d'un peu plus puissant comme le PIC32, car il devrait être capable de gérer toutes les fonctionnalités (par exemple, VGA de base) seul.
Voici une carte compatible Arduino, l' UNO32
Le Maximite est un ordinateur avec interprète BASIC basé autour d'un PIC32, vous voudrez peut-être regarder la conception et la construction pour quelques idées.

Votre chance, en quelque sorte, parce que je travaille actuellement sur un PC Arduino! Ce n'est pas grand-chose cependant, seulement le premier modèle. Le firmware est également très simple et dispose d'un petit ensemble d'API. Mais, la chose fonctionne! Pas assez bon pour éditer BASIC (ou n'importe quelle langue sauf la sienne), mais ce n'est que le premier modèle. La mobo est assez simple, et j'utilisé ce . Voici le firmware que j'ai utilisé:

        #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 description de la méthode est difficile à expliquer, mais le code est stocké sous forme d'octets bruts. Je devrais avoir un logiciel de développement bientôt ... J'espère que cela vous aidera! Si jamais vous souhaitez l'utiliser pour des projets, VOUS DEVEZ AVOIR UN fichier BIOS.mk8 dans le répertoire racine de la SD ou le système ne fonctionnera pas.

Avec tout le respect que je dois à David Brin (il se trouve que j'aime beaucoup ses livres; je ne suis pas qualifié pour juger de sa qualité d'astrophysicien), il n'est ni programmeur ni éducateur.

J'étais en train de coder dans les premiers jours des PC et j'ai écrit une bonne quantité de code BASIC. Et j'écris du code professionnellement depuis.

La raison pour laquelle nous avons utilisé BASIC à l'époque était que vos deux options étaient d'utiliser BASIC ou d'écrire dans l'assemblage, et l'assemblage était à la fois plus difficile à comprendre et beaucoup plus lourd à utiliser. Donc, BASIC.

Depuis plus de 30 ans, des améliorations importantes ont été apportées à l'enseignement de la programmation. Ma femme enseigne une classe de programmation débutante qui utilise Alice (www.alice.org), et c'est beaucoup mieux conceptuellement que les anciennes approches.

Je pense que la solution de Brin était assez élégante. Vous pourriez construire quelque chose d'assez simple sur un Raspberry PI. Sur l'arduino, je pense qu'il sera difficile de mettre tout ce dont vous avez besoin dans 2 Ko de RAM; qui doit contenir le système d'exploitation / moniteur que vous finissez par écrire, un interpréteur de commandes, du code pour faire l'affichage et le stockage du programme de base lui-même.

Sans parler du fait que vous allez devoir faire beaucoup de programmation difficile et personnalisée pour pouvoir écrire du code dans un environnement simple.

Je ne comprends pas. Si vous voulez seulement avoir un moyen de programmer en Basic, exécutez un interpréteur de base sur votre PC. Je ne comprends pas comment vous attendez de l'Arduino pour vous aider. L'Arduino est un microcontrôleur avec de nombreux logiciels sophistiqués pour cacher les détails du matériel. Une partie du coût de cela est des performances inférieures et une utilisation plus importante des ressources que le programme équivalent exécuté directement sur le microcontrôleur nu. Maintenant, vous voulez écrire du code Arduino pour le transformer en un ordinateur à usage plus général, tout cela pour que vous puissiez à son tour exécuter un interpréteur de base sur cet ordinateur à usage général? Cela n'a guère de sens.

Étant donné que votre seul objectif est de pouvoir éditer et exécuter des programmes de base (exécuter un interpréteur de base), commencez par une plate-forme informatique plus générale, de préférence même une qui dispose déjà d'un interprète de base. Votre PC est exactement une telle plateforme. Si vous voulez que ce soit du matériel externe, cela ressemble à un ordinateur à carte unique prêt à l'emploi qui répondrait beaucoup mieux à vos besoins qu'un Arduino.

Ajoutée:

Vous dites maintenant que vous ne voulez pas exécuter sur un PC et placez ce lien sur quelqu'un qui veut en ligne de commande Basic pour que son enfant apprenne. Certes, je n'ai pas lu l'intégralité de l'article (je n'aime pas que les gens répondent avec des liens. Vous devriez pouvoir exprimer votre point de manière indépendante en quelques phrases), mais je ne vois pas comment un PC exécutant une ligne de commande Interprète de base ne règle pas votre problème. Pourquoi l'interpréteur de base n'est-il pas autorisé à s'exécuter sur un PC mais est-il correct de s'exécuter sur un Arduino? Rappelez-vous, vous avez dit à l'avance que votre seul objectif était de modifier et d'exécuter des programmes de base. Rien dans cette déclaration ne dit sur quel matériel il doit fonctionner, et aucune de vos explications ultérieures n'explique pourquoi un PC ne fonctionnerait pas bien.

Il existe probablement des interprètes de base qui s'exécutent sur la ligne de commande. L'ancien QBASIC peut toujours fonctionner dans certains modes de compatibilité DOS. Même si ce n'est pas le cas, puisque vous êtes prêt à y consacrer du matériel, comment l'exécution de DOS et QBASIC sur un PC ne fournit-elle pas ce que vous avez demandé?

Liste des interprètes 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

J'aime l'idée d'exécuter une application commune, telle que BASIC sur un Arduino, surtout si vous l'avez vous-même construite à la main. J'aime la commodité d'avoir un appareil Arduino pratique et alimenté par batterie exécutant l'application que je voulais. Si c'était moi, j'utiliserais peut-être un Arduino MEGA, donc j'aurais assez de broches pour le clavier et un blindage SD pour le stockage.

Je choisirais un écran LCD graphique couleur ou un écran TFT sur VGA pour simplifier la programmation et les connexions, un moyen de garder une trace de la date et de l'heure (RTC), et qu'est-ce qu'une application sans Internet ni réseau (bouclier Ethernet)? Des RAM I2C supplémentaires (24LC256) peut-être? Et quelques I2C MCP223017 au cas où j'aurais besoin de quelques ports supplémentaires. Que diriez-vous de plusieurs Arduino effectuant une tâche parallèle? Cela améliorerait les performances, j'en suis sûr.