Jup, danke.
Jetzt kann ich mit der SVN-Version 27 Basicprogramme von meinem
selbstgebastelten Purebasic-Terminal rüberschicken/laden zum Atmega mit
einem ergänzten Befehl den ich "loadc" nenne statt "load", wo man die
programme ja eintippen kann.
Ist eine Tolle sache.
Sind in der SVN-31 mehr Bbefehle drin ?
Gruss
...SVN-31...
aus dem SVN-31 ist wohl das neueste, weil ja da die "main.c" nicht drin
ist wie in der SVN-27 Version, mit der ich die Programme ja seriell vom
Pc zum Atmega übertragen kann.
Gruss
MoinMoin,
ich habe gerade eine neue Version meines Zweiges des Basic-Interpreters
in das SVN übermittelt. Es hat sich nicht viel geändert:
* für AVR-Plattform wird PROGMEM weitreichender verwendet, wenn diese
Option eingeschaltet ist; damit kann mehr Platz im dynamischen RAM
gewonnen werden, wenn man viele CALL-Funktionen oder CVARS definiert
hat...
* ich hatte noch ein DG-16080
(Beitrag "Display mit Touchscreen bei Pollin?") seit einem Jahr
rumzuliegen und dachte mir, dass dies doch mal ein sinnvolles Beispiel
wäre, die entsprechenden Ausgabe-Funktionen via CALL-Befehl über den
Interpreter anzusprechen...
Vor allem der zweite Punkt war recht zügig umsetzbar und zeigte mir
damit, dass der CALL-Befehl eine recht coole Sache ist, um die
Funktionalität des Interpreters einfach erweitern zu können.
Grüße Uwe
Ich bin schwer beeindruckt von deiner Arbeit.
Irgendwie komm ich nicht mehr nach :-)
Echt Klasse wieviel und vor allem wie schnell du die Sachen da
reinprügelst :-)
MoinMoin,
Rene B. schrieb:> Echt Klasse wieviel und vor allem wie schnell du die Sachen da> reinprügelst :-)>
die Struktur des zugrunde liegenden Quelltextes ist einfach aufgebaut
und damit unkompliziert erweiterbar/anpaßbar.
Grüße Uwe
PS.: habe dir gestern Abend eine Mail geschrieben, lese mal und gebe ein
Statement dazu ab,,,
Die Struktur ist in der Tat sehr einfach und schön einfach zu erweitern.
Aber nichts desto trotz find ich das Klasse wie schnell du deine
Erweiterungen umsetzt :-)
Ich glaub ich häng da ein bissl hinterher xD
Hab dir geantwortet.
MoinMoin,
ich habe gerade eine neue Version (meines Zweiges) ins SVN gespielt.
Folgende Änderungen:
* ein paar Bug-Fixes
* alternativ sind BASIC-Programme ohne Zeilennummerierung erlaubt
Also so etwas z.B.:
1
print "Hallo Uwe"
2
for i=1 to 10
3
print i
4
next i
5
gosub 20
6
goto 10
7
print "hier nicht!"
8
10: rem ...
9
print "hier ist korrekt..."
10
end
11
12
20: rem UP...
13
print "Unterprogramm"
14
return
Falls jemand Bugs findet, wäre ich an entsprechenden Informationen dazu
interessiert...
Grüße Uwe
MoinMoin,
in der letzten Version hat sich eine kleine Ungenauigkeit
eingeschlichen, die bei BASIC-Programmen ohne Zeilennummerierung wirksam
wurde: in bestimmten Konstellationen las der Parser einen Befehl oder
ein Zeilenende zu weit.
Eine korrigierte Version habe ich gerade ins SVN gespielt.
Grüße Uwe
Ich bin ja mal wieder richtig begeistert von dem was du auf die Beine
stellst. Einfach nur klasse.
Ich versuche mal auch wieder etwas zum Basic beizutragen. Evtl hätte ich
die ein oder andere Kleinigkeit zu bieten ... mal schauen :-)
Ansonsten : Weiter so :-)
Bin mal gespannt was da noch alles kommt.
Rene B schrieb:
>Der Ansatz ist ein anderer. Es geht sich darum das Basic in ein>bestehendes System zu integrieren. Die Idee mit der "ladbarkeit" von>SD-Karte kam später durch ein paar "Spinnereien" zw Spielereien von Uwe>und mir.
Tjaja, so ist das mit den guten Ideen, man denkt immer, man hatte sie
selbst zuerst.
Ich nehme jetzt mal die Urheberschaft für mich in Anspruch:
chris schrieb:
>Sehr gut. Ins RAM müssen ja nur veränderbare Variablen. Das eigentliche>Basic-Programm kann ja auf einer SD-Karte residieren. Damit dürfte es>dann möglich sein, ziemlich große BASIC-Programme laufen zu lassen.>Was die Geschwindigkeit anbelangt, wäre ich mir nicht so sicher, ob das>Ganze wirklich so langsam wird. Theoretisch könnte man das RAM oder die>SD-Karte im Block-Mode auslesen, also z.B. immer 128Byte und dann so>eine Art Cache implementieren.
chris schrieb:> Rene B schrieb:>>Der Ansatz ist ein anderer. Es geht sich darum das Basic in ein>>bestehendes System zu integrieren. Die Idee mit der "ladbarkeit" von>>SD-Karte kam später durch ein paar "Spinnereien" zw Spielereien von Uwe>>und mir.>> Tjaja, so ist das mit den guten Ideen, man denkt immer, man hatte sie> selbst zuerst.>> Ich nehme jetzt mal die Urheberschaft für mich in Anspruch:>
du musst noch weiter oben lesen, dein Anmerkung bezieht sich auf eine
anderen Diskussionsgegenstand, wenn ich mich recht entsinne...
Grüße Uwe
Rene B. schrieb:> Bin mal gespannt was da noch alles kommt.>
Folgendes steht auf meinem Plan:
* Bugfixes, soweit Fehler gefunden werden
* INPUT-Befehl, um auch mal TicTacToe in BASIC spielen zu können... :-)
* DATA/READ/RESTORE
Grüße Uwe
Die Idee mit dem seriellem Speicher für Code und Variablen lokal im
schnellen Controller-RAM ist aber seeeeeeehr viel älter! Soll euch aber
nicht den Spaß verderben! Offensichtlich mehrfach erfunden. Ein altes
Beispiel, was recht interessant und fortgeschritten war, ist tinyboot -
eine Forth-Variante.
Es geht ja auch nicht unbedingt darum immer der erste zu sein oder was
"neues" zu erfinden oder ? :-)
Nur ich denke es ist ganz schön wenn sich so ein Projekt entwickelt und
man nach und nach neue Sachen einbaut die so zwar schon ein "alter Hut"
sind, aber das bisher aufgebaute noch erweitern, bzw das man das selbst
auch mal ausprobiert, und das dann in den Kontext eines Aufbau-Projektes
bringt.
Und oftmals zählt ja auch nur der Spaß an der Freud wie man so schön
sagt. Und das ist es ja auch was das Hobby Elektronik so interessant
macht.
Es fällt mir nur auf, das oftmals das Rad neu erfunden wird. Wenn man
eine Idee hat, googelt man zuerst danach. Wenn man was findet, kann man
sich die meisten Gedankengänge dann sparen (und kopieren). Selten kommt
ein Thema auf, das sich nicht zum Googeln eignet. Dann hat man Pech,
kann aber noch Experten fragen, notfalls zu passenden Stichworten für
die weitere Suche.
Habt viel Spaß!
ähmmmm, wo ist jetzt eigentlich das Problem?
Wenn ich nach jeder Idee, die ich so beim Einschlafen/Aufwachen habe,
googeln würde, hätte ich gar keine Zeit mehr die Sachen umzusetzen und
meine Freizeit würde irgendwie langweilig werden! Es geht hier um reines
Vergnügen und Selbermachen.
Achso, ich verstehe auch nicht ganz, warum hier plötzlich Bemerkungen
darüber hochkommen, wer wann, welche Idee geäussert hat. Muss ich
demnächst meine Postings auch noch notariell beglaubigen lassen?
Viel Spaß beim googeln & Grüße Uwe
>Die Idee mit dem seriellem Speicher für Code und Variablen lokal im>schnellen Controller-RAM ist aber seeeeeeehr viel älter! Soll euch aber>nicht den Spaß verderben! Offensichtlich mehrfach erfunden.
Stimmt, ich glaube die Basic Stamps von 1992 haben dieses Prinzip
verwendet:
http://en.wikipedia.org/wiki/BASIC_Stamp
chris schrieb:> Stimmt, ich glaube die Basic Stamps von 1992 haben dieses Prinzip> verwendet:> http://en.wikipedia.org/wiki/BASIC_Stamp>
wie jetzt, ich dachte von dir... hast du zumindestens vor ein paar
Minuten geschrieben.
Uwe, die Leute die hier posten sind einfach unterbeschäftigt, arbeitslos
oder krank bzw. süchtig.
Alle anderen haben keine Zeit oder haben keine Lust sich nach Feierabend
noch mit dem Beruf beschäftigen.
So einfach ist das.
Abdul K. (ehydra) Benutzerseite
>Uwe, die Leute die hier posten sind einfach unterbeschäftigt, arbeitslos>oder krank bzw. süchtig.
Welche der Eigenschaften trifft jetzt genau auf Dich zu?
chris schrieb:> Abdul K. (ehydra) Benutzerseite>>Uwe, die Leute die hier posten sind einfach unterbeschäftigt, arbeitslos>>oder krank bzw. süchtig.> Welche der Eigenschaften trifft jetzt genau auf Dich zu?
Mehr oder weniger alle genannten, wobei diese irgendwie meist
zusammenhängen. Aber vor allem wohl das krank sein.
Bin mal gespannt, wie ehrlich du nun zu uns und zu dir selbst bist?
Ich denke nicht, das ich das zu einseitig sehe.
>Vor allem ... was soll das rumstänkern ?
Eigentlich wollte ich das gar nicht. Falls es ein Problem gibt,
entschuldige ich mich dafür. Ich schlage vor, wir posten jetzt wieder zu
sachlichen und fachlichen Fragestellungen.
Sag mal Abdul .... wo genau besteht dein Problem nun ?
Wo ist das Problem wenn jemand aus "langeweile", "sucht", "krankheit"
oder einfach nur aus Spaß an der Sache sich hier beteilligt ?
Und warum mußt du das jemandem unterstellen obwohl keine Sau dir in
diesem Zusammenhang etwas unterstellt hat ? Würd mich mal interessieren
...
Wobei ... auch nicht so wirklich. Dieser Thread hat einen anderen
Diskussionsgegenstand und bei dem sollten wir auch bleiben. Wenns dir
nicht passt, verkneif dir Kommentare, genauso wie ich es Momentan mache
und überles den Thread doch einfach.
Erst wurde gehänselt, das einer für sich in Anspruch nimmt eine Idee
zuerst gehabt zu haben. Das habe ich richtig gestellt durch die Historie
dieser Idee. Das wurde mir wiederum angekreidet, ich wäre wohl zu
hochnäsig - oder wie man das kurz wiedergeben sollte. Zu guter Letzt
kümmerte man sich um meinen Geisteszustand. So nach der Art, der ist
doch eh doof, verkalkt oder neidisch. Nö, ich weiß das die Menschheit eh
bescheuert ist, daher ist das für mich kein Problem mit Kranken
umzugehen.
Warum sollte ich mir einen Kommentar verkneifen, wenn es einfach ne
Unwahrheit ist, zu behaupten, ein serielles Code-EEPROM wäre irgendwie
neu? Die Idee ist schlicht abgedroschen alt. Selbst in der
Öffentlichkeit oft genug dokumentiert. Von sicherlich 100x mehr
unveröffentlichten Privatprojekten ganz zu schweigen.
Fummelt weiter an eurem BASIC-AVR und gut ist. Ich werde nix mehr dazu
sagne.
@Abdul ...
Ich verkneif mir mal nen Kommentar zu dem Posting und mach dann lieber
an meinen Basteleien weiter. Selbst wenn sie vor 20-30 Jahren schonmal
erfunden worden sind. Modellbauer bauen ja auch nicht nur Modelle nach
die es noch nicht gibt, sondern weil sie Spaß daran haben, egal ob es
das Modell schon gibt oder obs was ganz eigenes ist.
Wie auch immer : Sag besser nix dazu wenns nichts konstruktives ist.
Sich über das Hobby eines anderen auszulassen ist eh fürn Eimer und sagt
was über denjenigen aus der etwas daran auszusetzen hat ...
Ja, das stimmt: Bislang begriff ich Elektronik immer als was neues. Das
Hobby hatte ich mir ausgesucht, weil es damals in meiner Kindheit etwas
war, was die meisten nicht kannten oder begriffen. Also was
'besonderes'.
Vielleicht sehe ich das zu eng, wenn mich nur neuartige Sachen
interessieren. Sachte ja: Laßt euch nicht stören - bastelt weiter!
MoinMoin,
seit ein paar Minuten steht eine neue Version meines Zweigs im SVN zur
Verfügung. In dieser Version ist die Implementierung des BASIC-Befehls
INPUT enthalten. Beispiel:
1
input "a="; a
2
print a
3
end
Grüße Uwe
PS.: ich kann mir folgende Bemerkung in Anbetracht der obigen Diskussion
nicht verkneifen: Der BASIC-Befehl INPUT ist keine Erfindung von mir,
sondern existiert bereits seit der Erstveröffentlichung dieser
Programmiersprache im Jahr 1964. Irgendwelche Streitigkeiten zu
Urheberrechten auf die Idee zu diesem BASIC-Sprachelement sind bitte an
die Herren J.G.Kemeny und T.E.Kurtz zu richten...
PPS.: sucht euch bitte eine andere Spielwiese, wenn ihr Langeweile habt
und mal nur so quatschen wollt...!
MoinMoin,
es steht eine neuer Version im SVN zur Verfügung.
In dieser Version habe ich ein Redesign der Unterstützung von Array
(BASIC-Befehl DIM...) vorgenommen, da es ein paar Ungereimtheiten gab.
Nebenbei ist auch der Code wieder lesbarer/kompakter geworden. Meine
erste Implementierung von Arrays war doch zu grottig...
Damit sind Arrays überall dort durchgängig einsetzbar, wo auch "normale"
Variablen stehen können --> siehe EBNF in der Doku. Auch "geschachtelte"
Array-Bezeichnungen und der Einsatz als Laufvariablen in
for/next-Schleifen sind jetzt wirklich möglich (... wenn man es denn
unbedingt braucht ;-)):
MoinMoin,
in der aktuellen Version im SVN sind jetzt die BASIC-Befehle
DATA/READ/RESTORE realisiert. Doku und EBNF sind entsprechend angepasst.
Ein BASIC-Beispiel dazu:
MoinMoin,
habe gerade eine neue Version meines BASIC-Interpreters ins SVN
übermittelt.
In dieser Version ist durchgängig die Verarbeitung von Zeichenketten
implementiert:
* Zeichenkettenvariablen lauten z.B. a$, b$. Also ist z.B. folgendes
möglich:
1
a$="BASIC ist cool!"
2
print a$
* es sind Zeichenkettenfelder zulässig, wenn sie mit DIM deklariert
wurden, also z.B.:
1
dim a$(10)
2
a$(0)="BASIC ist immer noch cool!"
3
print a$(0)
* es gibt eine Reihe von Funktionen zur Zeichenkettenverarbeitung (siehe
auch Doku):
** left$
** right$
** mid$
** str$
** chr$
* es gibt ein paar weitere Funktionen, welche Zeichenketten voraussetzen
(siehe auch Doku):
** val
** asc
** len
* Teil-Strings können mit dem Operator '+' zusammengefügt werden
* die üblichen Vergleichsoperationen (<, >, =, <=, >=, <>) gelten auch
für Zeichenketten
* Zeichenketten können via input eingelesen werden
* Zeichenketten können via data/read deklariert/eingelesen werden
Wenn ich etwas vergessen haben sollte, ...aktualisierte Doku lesen!
Ein Hinweis zu Zeichenketten: man sollte sich schon sehr gut überlegen,
ob man die Zeichenkettenunterstützung im Interpreter einschaltet
(ubasic_config.h --> Define UBASIC_STRING), wenn man sehr ressourcenarme
Plattformen vor sich hat. Es wird (zur Laufzeit eines BASIC-Programmes)
teilweise unverhältnismäßig viel Speicher für Zeichenkettenvariablen
bzw. -felder reserviert (man beachte vor allem das Define MAX_STRINGLEN
in ubasic_config.h).
Ausblick auf weitere Versionen des BASIC-Interpreters:
TheMason hat gerade einen genialen Parser in der Mache, der für den
BASIC-Interpreter einen Performance-Schub von Faktor 2-3 bringen würde.
Schauen wir mal...
Ansonsten bin ich eigentlich fast "am Ende der Fahnenstange". Es fehlt
einzig nur noch ein Unterstützung von gebrochenen Zahlen (plus
entsprechender Funktionen), die ich für meinen ursprünglich geplanten
Einsatzzweck des Interpreters nicht benötige...
Grüße Uwe
PS.: Fehler innerhalb des Interpreters dürfen mir gern gemeldet werden!
MoinMoin,
neben grundlegenden BASIC-Dingen auch mal etwas zur Erholung:
Ich hatte mir letztens für mein Arduino Duemilanove
(http://www.arduino.cc/en/Main/ArduinoBoardDuemilanove) ein
Data-Logging-Shield von Adafruit
(http://www.adafruit.com/products/243&zenid=814bcdbebc5a8ad8f553a48cdf0e1a39)
zugelegt (nein, ich mache jetzt keine Werbung...!). Zur Entspannung habe
ich meinen BASIC-Interpreter mal vollständig auf dieser
Hardwarekonstellation zur Entfaltung gebracht:
* SD-Card-Unterstützung via Lib von Roland Riegel
(http://www.roland-riegel.de/sd-reader/)
* RTC DS1307 auslesen via TWI-Lib von Peter Fleury
(http://homepage.hispeed.ch/peterfleury/avr-software.html),
implementiert als BASIC-Befehl call()
Die aktuellste AVR-BASIC-Version im SVN beinhaltet diese Anpassungen:
* entsprechendes Makefile: Makefile_arduino
* maßgebend ist dabei das Rahmenprogramm ubasic_avr_sd.c
* Das entsprechende BASIC-Programm zum Auslesen des RTC sieht dann z.B.
ungefähr so aus (natürlich von SD-Card eingelesen ;-)):
neuer schrieb:> Ich die 53ziger drauf und die läuft mit dem Atmega644p.
freut mich, wenn es ohne Probleme bei dir läuft!
Hast du einen bestimmten Hintergrund, warum du den Interpreter
ausprobiert hast?
Grüße Uwe
MoinMoin,
Udo schrieb:> Wie schwierig wäre es eigentlich,> mehrere BASIC-Programme parallel laufen zu lassen?>
Wie meinst du das genau?
Mehrere unterscheidliche BASIC-Programme gleichzeitig (im gleichen
Interpreter) wird nicht so ohne weiteres realiserbar sein, denn dann
braucht man irgendetwas um ständig den Kontext (mit allen Konsequenzen,
also sämtliche Stacks und Programmzeiger auf den Quelltext) umschalten
zu können.
Was willst du denn konkret machen?
Grüße Uwe
Hallo Uwe,
im Moment habe ich noch kein konkretes Problem, welches ich damit lösen
möchte. Allerdings habe ich beim Programmieren von kleinen mobilen
Robotern festgestellt, dass es dort extrem nützlich ist, wenn man
mehrere Programme parallel ablaufen lassen kann. Es ist z.B. oft
notwendig, die Geschwindigkeitsregelung der Motoren oder
Positionsberechnungen parallel zum eigentlichen Steueralgorithmus laufen
zu lassen. Dafür wäre ein BASIC-Interpreter vielleicht ganz gut.
Gruß,
Udo
MoinMoin,
Udo schrieb:> Es ist z.B. oft> notwendig, die Geschwindigkeitsregelung der Motoren oder> Positionsberechnungen parallel zum eigentlichen Steueralgorithmus laufen> zu lassen.>
also irgend welche Regelungsaufgaben, welche wohlmöglich auch noch
zeitkritisch sind, sollte man keinem Interpreter überlassen, da solche
Dinger, nicht nur meiner, zu langsam arbeiten. Das sollte man lieber in
der einbindenden Applikation erledigen.
Solch ein Interpreter ist mehr für nachladbare Programme geeignet, also
aus Sicht deines Roboters vielleicht:
* eine Aufgabe (finde einen Gegenstand suchen, Linie folgen etc.)
* ein Verhalten (fahre Zickzack, im Kreis etc.)
* usw....
Im c't-Bot-Projekt wurde z.B. deshalb mein BASIC-Interpreter als
sinnvoll erachtet und in den aktuellen Entwicklungszweig aufgenommen.
Grüße Uwe
So ...
nach einer kleinen Zwangspause melde ich mich auch mal wieder zu Wort
:-)
Wie Uwe schon geschrieben hat bin ich gerade dabei den Tokenizer ein
kleines bischen zu optimieren. Es wird zwei Optimierungsschritte geben,
wovon der erste schon umgesetzt ist, aber noch nicht weiter getestet bzw
noch nicht im SVN eingefügt ist. Der zweite Schritt dürfte auch noch
einen nicht unerheblichen Faktor ausmachen. Aber dazu werd ich erst
etwas schreiben wenn es soweit ist, da ich außerdem diese Optimierung
bzw Version des Tokenizers für meine Parser-Reihe verwenden kann.
Jedenfalls dürfte bzw wird es bald von mir auch einen Beitrag zum Thema
Basic geben.
@Udo
Die Idee mehrere Basic-Programme parallel laufen zu lassen (quasi
Thread-ähnlich) ist mir auch schon gekommen. Das wäre wie Uwe schon
geschrieben hat recht aufwendig, aber dennoch vorstellbar und ich denke
auch machbar. Ich selbst hab da auch schon ein paar Ideen zu, allerdings
nicht weiter verfolgt, da das Basic dann anders organisiert werden
müsste, sprich es würde sich von der Struktur her deutlich von dem
aktuellen Basic bzw der Version von Adam Dunkels unterscheiden.
...Hast du einen bestimmten Hintergrund, warum du den Interpreter
ausprobiert hast?...
Mit 62 Jahren ist man neugierig, wie so etwas funktioniert, was vor 30
Jahren moch ein grosse Kiste war und jetzt ein Atmega.
Ich finde so ein Projekt toll.
gruss
MoinMoin,
es hat doch tatsächlich jemand gemerkt (und bei mir angefragt, da es
gebraucht wurde): bisher war es nicht möglich innerhalb eines
if-Statements mehrere Relationen mittels logischen Operator (and, or) zu
verbinden...
In der aktuellen Version im SVN geht dies nun.
Beipiel:
1
a$="1"
2
b$="2"
3
if a$<"1" or b$="2" then print "then" else print "else"
4
5
c=1
6
d=2
7
if c=1 and d=1 then print "then" else print "else"
8
9
if a$="1" or c=2 then print "then" else print "else"
10
11
end
Es geht aber weiterhin nicht:
* Negation des Ergebnis einer Relation
* Klammerung von Relationen
... aber so komplexe BASIC-Programme wird keiner schreiben, oder?
Grüße Uwe
MoinMoin,
beim Rumspielen mit diversen alten BASIC-Programmen, die ich irgendwo
gefunden hatte und mit meinem Interpreter ausprobiert habe, sind mir ein
paar Unzulänglichkeiten aufgefallen. Diese sollten mit der aktuellen
Version im SVN behoben sein. Folgendes wurde geändert:
* Bug-Fix:
** negative DATA-Werte zulaessig
** leere REM-Anweisung zulaessig
** leere Zeichenkette "" zulaessig
** Korrektur STRING_TO_LARGE
* neue Funktionalitäten:
** print tab(n)
** m_strlen, upper$, lower$, instr$
** Doku entsprechend angepasst
Grüße Uwe
Hallo, ich suche eine Lösung um die Bas-Programme vom Pc zu laden.
Das PC-programm ist kein Problem, nur wie kann das Basic die Daten
seriell empfangen und an den richtigen Ort ablegen zum starten.
Wäre um eine hilfe dankbar.
Danke.
gruss
Also Basic-Programme vom PC aus zu laden müsste separat implementiert
werden. Das Basic selbst kann das nicht übernehmen da es erstmal
unabhängig von der Art der Speicherung der Programme programmiert ist.
Sprich : Ob die Programme im Flash, auf einer SD-Karte, im RAM oder
EEPROM stehen ist dem Basic selbst egal. Dafür gibt es Routinen mit
denen man von jedwedem Medium aus das Programm laden bzw laufen lassen
kann.
Wie die Programme da hin kommen ist implementierungssache.
Du müsstest dir (wenn du beispielsweise als Medium eine SD-Karte nutzt)
selbst den Teil schreiben damit die Programme vom PC auf die SD-Karte
kommen.
Ebenso das Starten der Programme müsstest du machen.
Wie gesagt ist der Interpreter frei in seiner An- und Verwendung. Das
macht ihn so flexibel. Andereseits muß man bestimmte Dinge dazu selbst
programmieren.
Ich empfehle dir einen Blick in die Doku. Da steht das ganze nochmal
ausführlich erklärt.
MoinMoin,
ich habe gerade eine neue Version des AVR-BASIC-Interpreters ins SVN
gespielt. Am BASIC-Befehlsumfang hat sich nichts geändert, sämtliche
Änderungen betreffen interne Optimierungen und Fehlerbeseitigungen:
* Bug-Fix: GOTO-Label in erster Programmzeile mit eingeschaltetem
GOTO-Cache funktioniert nicht korrekt (gemeldet Jörgen)
* Typ-Definitionen besser nach "Lehrbuch" strukturiert (alles in *.h)
* FastParser von TheMason eingebaut (noch ohne Build-Tool fuer
Binaerbaum...)
Letzter Punkt ist die entscheidende Neuerung! TheMason hat seinen Parser
aus einem seiner anderen Projekte dem Interpreter zur Verfügung
gestellt. Damit verbessert sich die Performance des Interpreters
teilweise extrem (abhängig vom Umfang des BASIC-Programms). Das ganze
basiert, vereinfacht gesprochen, auf die Zerlegung der gültigen
Schlüsselwörter in einen Binärbaum, der mit optimierten Algorithmen
effizient durchlaufen werden kann. Damit reduzieren sich vor allem
diverse Vergleichsoperationen und damit verbundene (und u.U. teilweise
langsame) Speicherzugriffe.
Einziger "Wermutstropfen": TheMason hat mich darum gebeten das Tool zur
Generierung des Binärbaums vorerst nicht zu veröffentlichen. Grund ist
wohl, dass er erst sein dazu parallel laufendes Projekt fertigstellen
möchte, bevor er sämtliche KnowHow offenlegt...
D.h. vorerst, wenn jemand eigene BASIC-Befehle kreiert und den schnellen
Parser verwenden möchte (einschaltbar durch ein entsprechendes Define in
ubasic_config.h), muss mich anschreiben, damit ich die entsprechenden
Daten generiere.
Grüße Uwe
PS.: Doku ist noch nicht entsprechend angepasst, wird nachgeliefert...
PPS.: es scheint tatsächlich Leute zu geben, die den BASIC-Interpreter
in eigene Projekte einbauen. Ich würde mich über eventuelle Bug-Reports
freuen...
MoinMoin,
im SVN gibt es mal wieder eine neue Version des BASIC-Interpreters.
Neben einer kosmetischer Verbesserungen steht jetzt auch das Build-Tool
zur Generierung des Binär-Baumes für den FastParser von themason zur
Verfügung (--> Danke Renè!). Die Doku wurde entsprechend
angepasst/erweitert.
Sollten Fehler oder Fragen bestehen, freue ich mich über jeden Hinweis.
Grüße Uwe
MoinMoin,
in der aktuellen SVN-Version (65) ist der Zugriff auf einen externen
Dataflash als BASIC-Programm-Ablage implementiert.
Mir ist neulich mein Etherrape-Board (http://lochraster.org) in die
Hände gefallen, auf dem u.a. ein Atmel Dataflash vom Typ AT45DB041B
verbaut ist. Da dachte ich mir, dass es ganz nett wäre diesen Dataflash
als BASIC-Programm-Speicher zu verwenden. Die entsprechenden
Zugriffsroutinen und das darauf aufsetzende Filesystem wurden dem
Ethersex-Projekt (http://ethersex.de) entnommen.
Vielleicht mal an diesem Punkt zusammengefasst, auf welchen Plattformen
derzeit mein Interpreter lauffähig ist:
AVR-Hardware:
-------------
* Arduino-Board (Duemilanove, Mega328) mit SD-Karten-/RTC-Erweiterung
* Etherrape-Board
* ein Testboard mit Mega168 oder Mega328 und serieller Schnittstelle
* AL-ERAM128_256 Version 2.0 von ALVIDI (getestet von Jörgen)
* c't-Bot
als Standalone-Programm unter:
------------------------------
* Linux
* Windows (unter MinGW)
Falls jemand den Interpreter auf anderen Plattformen ausprobiert hat,
wäre ich an einer kurzen Info interessiert.
Grüße Uwe
Hi @ all
Wie Uwe schon geschrieben hat, gibt es schon einige Boards auf dem
uBasic am laufen ist. Momentan erstelle ich die Pollin-Net-IO Version.
Vorgesehen ist, die Programme von SD-Karte zu lesen. Diese kommt als
extra Board an den ISP Secker. Die geänderten Daten werde ich Uwe
übergeben.
Gruß
Jörgen
MoinMoin,
in der aktuellen Version (siehe SVN) des BASIC-Interpreters ist ein
Full-Screen-Editor integriert, der das Editieren von BASIC-Programmen
direkt "auf" der MCU, ein entsprechendes Speichermedium vorausgesetzt,
ermöglicht.
Siehe dazu auch:
Beitrag "Re: MCURSES - Mini Curses Bibliothek für Mikrocontroller"
Grüße Uwe
Hallo, guten Tag.
Ich habe dieses wunderbare Basic in der mache.
Mit der SD-Karte läuft es wunderbar.
Nun möchte ich den Basic-code via RS232 zum AVR schieben vom PC.
Dieses verstehe ich nicht vom unteren Programm:
* Basic-Programm wird direkt via Filesystemzugriffe gelesen.
Von wo liest der AVR denn dieses Programm ein? oder wird es gleich mit
ein gebunden beim compilieren?
Läuft es auch mit den 1284p genau so sicher wie mit dem 644p ?
danke.
gruss
/*----------------------------------------------------------------------
------
* Testprogramm fuer ubasic_avr-Interpreter
* ========================================
* Uwe Berger (bergeruw@gmx.net); 2010
*
* ==>> Basic-Programmtext steht in einer Datei <<==
* ---------------------------------------
*
* Basic-Programm wird direkt via Filesystemzugriffe gelesen.
*
* Syntax: ubasic <Dateiname_des_Basic-Programms>
*
*
* Have fun!
* ---------
*
*
------------------------------------------------------------------------
----*/
#include "avr_basic/ubasic_config.h"
#include "avr_basic/tokenizer_access.h"
#include "avr_basic/ubasic.h"
#include "avr_basic/ubasic_ext_proc.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
/*----------------------------------------------------------------------
-----*/
/*----------------------------------------------------------------------
-----*/
/*----------------------------------------------------------------------
-----*/
int main(int argc, char* argv[]) {
#if UBASIC_EXT_PROC
extern char current_proc[MAX_PROG_NAME_LEN];
#endif
// ist in tokenizer_access.c deklariert...
extern FILE *f;
printf("uBasic-Interpreter; Uwe Berger, 2010\r\n");
printf("Compiliert am "__DATE__" um "__TIME__"\r\n");
// Programm-Parameter behandlen
if(argc < 2) {
printf("Parameterfehler!\n");
printf("Syntax: ubasic <Dateiname_des_Basic-Programms>\n");
exit(1);
}
// Basic-Programm von Datei einlesen
f = fopen(argv[1], "rb");
if (!f) {
printf("Fehler beim Oeffnen der Datei: %s\n", argv[1]);
exit(1);
}
#if UBASIC_EXT_PROC
strncpy(current_proc, argv[1], MAX_PROG_NAME_LEN);
#endif
// Basic-Programm interpretieren
ubasic_init(0);
do {
ubasic_run();
} while(!ubasic_finished());
fclose(f);
exit(0);
}
MoinMoin,
neua schrieb:> Dieses verstehe ich nicht vom unteren Programm:> * Basic-Programm wird direkt via Filesystemzugriffe gelesen.>> Von wo liest der AVR denn dieses Programm ein? oder wird es gleich mit> ein gebunden beim compilieren?>
du hast dir die Version des Testprogramms gegriffen, die auf einem PC
läuft und den Basic-Quelltext von der Festplatte liest.
neua schrieb:> Läuft es auch mit den 1284p genau so sicher wie mit dem 644p?>
ich habe es, in Ermangelung eines Mega1284, nicht ausprobiert, mir fällt
aber kein Grund ein, warum der Basic-Interpreter dort nicht laufen
sollte.
Grüße Uwe
MoinMoin,
...ab und zu beschäftige ich mich noch mit dem BASIC-Interpreter! Ich
habe gerade im SVN eine neue Version veröffentlicht:
* neue Anweisungen PUSH und POP
* Dokumentation entsprechend angepasst
Mit PUSH kann man Integer-Werte auf einen internen Stack schieben, mit
POP holt man diese wieder und ordnet sie Variablen zu ("last input,
first output"). Also ungefähr so:
1
a=42
2
push a, 23, a+8
3
pop a, b, c
4
print a, b, c
Ausgabe sollte sein: 50 23 42
Für Zeichenketten funktionieren die beiden Anweisungen nicht, wenn ich
es mal gebrauchen könnte, werde ich es vielleicht auch noch
implementieren.
Anwendungsgebiete kann sich jeder selbst ausdenken, ich hatte vor allem
dabei Variableninhaltstausch ohne Zwischenvariable und das
Sichern/Rücksichern von Variableninhalten bei gosub im Sinn gehabt...
Grüße Uwe
Thread beobachten
Seitenaufteilung abschalten