Een functionele computer maken van een Arduino Uno

Het toetsenbord kan gewoon gedaan met een PS / 2-toetsenbord – het is gewoon serieel, en er zijn genoeg tutorials voor.

Het opslaan van gegevens kan eenvoudig worden gedaan op een SD-kaart – er is een schild uit er al om dat te doen.

Wat betreft de video – dat is aanzienlijk moeilijker. Als je wilt dat de Arduino bijvoorbeeld een PAL-videosignaal genereert, dan heb je je werk uit handen. Ja, het is mogelijk, en iemand heeft een Arduino “pong” -spel gemaakt, maar het zijn erg dikke graphics en alleen zwart-wit.

Voor VGA heb je een of andere interface nodig om het werk voor je te doen. Sparkfun verkocht vroeger de Picaso-videokaart die kon worden gemaakt om te werken met de Arduino, maar helaas is deze stopgezet en zijn er nog geen plannen voor vervanging .

TBH is het beste om zoiets als een Wyse-terminal te gebruiken en volledig serieel met de Arduino te communiceren. Veel eenvoudiger dan rommelen met videosignalen en dergelijke.

Ik zie het punt van Olin hier – als je alleen BASIC wilt bewerken / uitvoeren / leren, gebruik dan gewoon een pc .

Als het doel echter de uitdaging is om een computer te maken die BASIC kan draaien en tegelijkertijd de hardware en implementatie op een lager niveau kan leren, dan is dit een beetje anders. Ik ben helemaal voor dit soort dingen , het is een geweldige manier om kennis te verbeteren en u zult er zeker veel uit halen. Zoals Steven alle verwarrende en (meestal) irrelevante lagen noemt die b.v. Windows kan worden verwijderd, waardoor de basisconcepten (zonder woordspeling) overblijven.

Hoe dan ook, je misschien wil hiervoor naar iets krachtigers kijken, zoals de PIC32, omdat het alle functionaliteit (bijv. standaard VGA) op het is eigen.
Hier is een Arduino-compatibel bord, de UNO32
De Maximite is een computer met BASIC-interpreter gebaseerd op een PIC32, misschien wil je het Ontwerp en constructie bekijken voor een paar ideeën.

Opmerkingen

• Gezien de specificaties van pc ‘ s met Microsoft Basic onder een Z80, zou er geen echt probleem moeten zijn .

Je hebt geluk, min of meer, want ik werk momenteel op een Arduino-pc! Het is echter niet veel, alleen het eerste model. De firmware is ook heel eenvoudig en heeft een kleine API-set. Maar het ding werkt! Niet goed genoeg om BASIC (of een andere taal dan zijn eigen taal) te bewerken, maar dit is alleen het eerste model. De mobo is vrij eenvoudig en ik heb this gebruikt. Hier is de firmware die ik heb gebruikt:

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

De beschrijving van de methode is moeilijk uit te leggen, maar de code wordt opgeslagen als onbewerkte bytes. Ik zou binnenkort ontwikkelsoftware moeten hebben … Ik hoop dat dit helpt! Als je dit ooit voor projecten wilt gebruiken, JE MOET EEN BIOS.mk8-bestand hebben in de root-directory van de SD, anders werkt het systeem niet.

Opmerkingen

• Geluk inderdaad, als hij hasn ‘ t heeft het ontdekt in de drie jaar sinds hij het voor het eerst vroeg.
• @ScottSeidman Ja, goed punt. De firmware wordt ook nog getest, en dit versie mist sleutelelementen.

Met alle respect aan David Brin (ik vind zijn boeken toevallig erg leuk; Ik ben niet gekwalificeerd om te beoordelen hoe goed hij is als astrofysicus), hij is noch programmeur, noch opvoeder.

Ik was rond en codeerde in de begintijd van pcs, en ik schreef een behoorlijke hoeveelheid BASIC-code. En ik heb sindsdien professioneel code geschreven.

De reden dat we toen BASIC gebruikten, was dat je twee opties waren om BASIC te gebruiken of om in assembly te schrijven, en assembly was zowel moeilijker te begrijpen als veel meer. omslachtig in het gebruik. Dus, BASIC.

In de meer dan 30 jaar sindsdien zijn er aanzienlijke verbeteringen opgetreden in de programmeerinstructies. Mijn vrouw geeft les aan een beginnende programmeerles die Alice (www.alice.org) gebruikt, en het is conceptueel veel beter dan de oudere benaderingen.

Ik denk dat de oplossing van Brin behoorlijk elegant was. Je zou iets vrij eenvoudigs kunnen bouwen op een Raspberry PI. Op de arduino denk ik dat het een uitdaging zal zijn om alles wat je nodig hebt in 2K RAM te proppen; dat moet het besturingssysteem / de monitor bevatten die je uiteindelijk schrijft, een opdrachtinterpretator, code om de weergave te doen en opslag voor het basisprogramma zelf.

Niet om vermeld het feit dat u een heleboel moeilijke en aangepaste programmering zult moeten doen, zodat u code kunt schrijven in een eenvoudige env strijken.

Ik snap het niet. Als je alleen een middel wilt hebben om in Basic te programmeren, voer dan een tolk op je pc. Ik begrijp niet hoe je verwacht dat de Arduino hierbij helpt. De Arduino is een microcontroller met veel mooie software om de hardwaregegevens te verbergen. Een deel van de kosten daarvan zijn lagere prestaties en meer bronnengebruik dan het equivalente programma dat rechtstreeks op de kale microcontroller wordt uitgevoerd. Nu wil je Arduino-code schrijven om er weer een computer voor meer algemene doeleinden van te maken, zodat je op zijn beurt een basisinterpreter kunt uitvoeren op die computer voor algemene doeleinden? Dit heeft weinig zin.

Aangezien het uw enige doel is om basisprogrammas te kunnen bewerken en uitvoeren (een basisinterpreter draaien), begint u in de eerste plaats met een meer algemeen computerplatform, bij voorkeur zelfs een dat heeft al een Basic-tolk beschikbaar. Uw pc is precies zon platform. Als je wilt dat dit externe hardware is, klinkt het alsof een standaard computer met één bord veel beter aan je behoeften voldoet dan een Arduino.

Toegevoegd:

Je zegt nu dat je wil niet op een pc draaien en deze link plaatsen over iemand die de commandoregel Basic wil waarvan zijn kind kan leren. Toegegeven, ik heb het hele artikel niet gelezen (ik hou er niet van dat mensen antwoorden met links. om je punt onafhankelijk in een paar zinnen te formuleren), maar ik zie niet hoe een pc met een commandoregel Basic interpreter je probleem niet aanpakt. Waarom mag de Basic interpreter niet op een pc draaien, maar het is oké om op een Arduino te draaien? Onthoud dat u van tevoren zei dat uw enige doel was om basisprogrammas te bewerken en uit te voeren. Niets in die verklaring zegt op welke hardware het moet draaien, en geen van je volgende uitleg verklaart waarom een pc het niet goed zou doen.

Er zijn waarschijnlijk basisinterpreters die op de opdrachtregel draaien. De oude QBASIC werkt mogelijk nog steeds in een of andere DOS-compatibiliteitsmodus. Zelfs als dat niet het geval is, aangezien u bereid bent hier hardware aan te wijden, hoe geeft het uitvoeren van DOS en QBASIC op een pc dan niet wat u vroeg? / h3>

• Mijn punt was dat ik ‘ niet wil programmeren op een pc. Ik wil programmeren in een vergelijkbare omgeving als bijvoorbeeld een Texas Instruments TI-84 +. Mijn reden hiervoor? Bekijk de volgende link, ” Waarom Johnny Can ‘ t Code ” salon.com/technology/feature/2006/09/14/basic/index.html
• Dit is niet echt een antwoord.Ja, het idee van het OP is misschien een beetje links van het midden, maar waar zouden we zijn als niemand ooit iets buitengewoons zou proberen, of om de grenzen te verleggen van wat al bestaat? Het OP vertellen dat het ‘ een dom idee is, is noch nuttig noch constructief. Het OP heeft besloten dat hij ‘ het graag zou willen doen, en vraagt ons om hulp bij het aanpakken ervan. Hij ‘ vraagt niet of het ‘ een goed idee is of niet. Ja, het is misschien wel een slecht idee ™, maar het OP zal enorm veel leren terwijl hij dat ontdekt, wat zelf waardevoller kan zijn dan het eindresultaat.
• @Majenko: Wat ik schreef is een redelijk antwoord op wat het OP oorspronkelijk schreef. Onthoud dat hij zei ” Mijn enige doel voor deze computer is de mogelijkheid om BASIC-programmas te bewerken en uit te voeren ” . Dit zegt ‘ niets over het draaien op alternatieve hardware. Blijkbaar wil hij een eenvoudige commandoregel Basic-tolk om kinderen te onderwijzen. Hoe is het om zoiets op een pc te draaien geen geldig antwoord? Is niet ‘ een pc met QBASIC of zoiets precies wat hij ‘ s vraagt?
• @Olin Het OP is het daarmee eens met mij … Ik denk dat je de vraag verkeerd interpreteert.
• @Olin – ik kan Butts begrijpen. Herinner je je thuiscomputers van eind jaren 70, begin jaren 80 nog? Je hebt een geheugen toegewezen 74LS373 en je zou I / Os kunnen besturen via poke instructies. Geen virtuele COM-stuurprogrammas om te installeren, geen USB naar welke brug dan ook, geen complexe ontwikkelaar-IDE om te laden. SBCs zijn vergelijkbaar, maar missen over het algemeen de toetsenbord / video-interface (en cassette-opslag!) Van de thuiscomputers.

Lijst met AVR BASIC-tolken:

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

Ik hou van het idee om een gewone app, zoals BASIC, op een Arduino uit te voeren vooral als je het zelf met de hand hebt gebouwd. Ik hou van het gemak van een handig, batterijgevoed Arduino-apparaat met de app die ik wilde. Als ik het was, zou ik misschien een Arduino MEGA gebruiken, dus ik had genoeg pinnen voor het toetsenbord en een SD-schild voor opslag.

Ik zou een kleuren grafisch LCD-scherm of een TFT-scherm over VGA kiezen. voor eenvoud in programmeren en verbindingen, een manier om datum en tijd (RTC) bij te houden, en wat is een app zonder internet of netwerken (ethernetschild)? Extra I2C RAMs (24LC256) misschien? En een paar I2C MCP223017 voor het geval ik een paar extra poorten nodig zou hebben. Hoe zit het met meerdere Arduinos die een parallelle taak uitvoeren? Dat zou de prestaties zeker verbeteren.

Reacties

• Links naar datasheets worden gewaardeerd door de gemeenschap. Gebruik ook niet te veel hoofdletters en zorg ervoor dat uw antwoord leesbaar is door spaties toe te voegen.
• Zoals het is, is dit een antwoord van zeer slechte kwaliteit. Maar er zijn hier enkele gevoelens die de moeite waard kunnen zijn als ze worden opgeruimd en beter worden gepresenteerd.