Propeller und Forth

[drohne235]

Hey, das ist cool. Gibt es eigentlich konkrete Pläne was du mit dem Aufbau machen möchtest?

[MarkusG]

Das ist jetzt hier vielleicht etwas Off-Topic

Ich hab einen kleinen Kommandozeilen SPIN loader geschrieben, oder besser gesagt angepasst.
Gibts natürlich schon, aber diese Version läuft auch auf einem ARM unter Linux (Windows 386 und Linux 386 auch)

Näheres incl. Quellcode hier:
http://forums.parallax.com/showthread.p ... processors


Ziel ist ein (Multi-)Propeller IO Slave unter PropForth für einen ARM Master unter Linux.

Grüße
Markus

[yeti]

Dieses Helferlein hat auch hier 'n eigenen Thread verdient... start den mal ruhig...

[MarkusG]

So jetzt gehts wieder ein bischen weiter mit meinem Projekt

Ich habe ja oben geschildert dass ich Daten über die serielle Schnittstelle austauschen möchte. Das geht auch so weit.
Jetzt muss ich aber auf der Schnittstelle einen Break senden, d.h. einfach 2ms Signal low auf TdX.
Naiver Ansatz

4 5 9600 2 startserialcog

4 pinlo
2 delms
4 pinhi

Das geht aber nicht so recht offensichtlich hält der serialcog den port 4 eißern auf 1

Sauberere wäre sicher ein break Befehl f. die serielle Schnittstelle

Irendwelche Ideen?

Grüße

Markus

[drohne235]

Zwei Ideen:

1. Die SerialCog in Assembler ein wenig erweitern.

2. Die serialcog temporär beenden, selbst die Leitungen von Forth aus steuern und danach die serialcog wieder starten.

Zu Version 1: Wenn ich es recht in Erinnerung habe, erkennt die serialcog an ihrer Eingangsvariable (32Bit!) durch ein gesetztes Bit 8 (also 0x000001nn), dass der Wert im unteren Byte gesendet werden soll. Mit einem anderen Bit könnte man also durchaus weitere Funktionen aufrufen, wie eine Break-Funktion.

Zu Version 2: Im Startmechanismus von PropForth kann man sich anschauen, wie die serialcog gestartet wird. Beenden ist ja kein Problem, die Break-Funktion dann schön komfortabel in einem Forthwort.

Das sind die Sachen die mir so ganz spontan einfallen, sollte problemlos machbar sein. Am einfachsten ist wahrscheinlich Variante 2, da man da alles bequem unter Forth testen kann - sowas ist ja immer eine Stärke von Forth.

[MarkusG]

Zwei Ideen:

1. Die SerialCog in Assembler ein wenig erweitern.

dafür hab ich mich jetzt entschieden, da geht auch schon, werd ich morgen posten.
Ich habe ein Zeichen | = ASCII 7C genommen wenn das kommt, wir einfach ein 32 bit $FF rausgeclockt, das sollt als break reichen.

Lieber wäre mir ASCII 00 gewesen, da das per Definition eher ein break wäre aber ich seth vor folgendem Problem in Forth:

mit

Code: Alles auswählen

c" x " 2 cogx

kann ich einen festen String über den mit startserialcog gestarteten cog 2 ausgeben. Soweit verstanden.
Jetzt will ich aber z.B. ein Steuerzeichen ausgeben sagen wir mal $19.
Wie kann ich meherer AsCII zeichen zu einem Cstr zusammenbasteln und dann mit cogx ausgeben?

Das ganze Variablen, Character, Strin Handling in PropForth ist mir noch sehr schleierhaft.

Außerdem wird nach dem String noch ein CR LF ausgegeben, aber ich denke das kann ich ihm abgewöhnen.

2. Die serialcog temporär beenden, selbst die Leitungen von Forth aus steuern und danach die serialcog wieder starten.

Zu Version 1: Wenn ich es recht in Erinnerung habe, erkennt die serialcog an ihrer Eingangsvariable (32Bit!) durch ein gesetztes Bit 8 (also 0x000001nn), dass der Wert im unteren Byte gesendet werden soll. Mit einem anderen Bit könnte man also durchaus weitere Funktionen aufrufen, wie eine Break-Funktion.

Zu Version 2: Im Startmechanismus von PropForth kann man sich anschauen, wie die serialcog gestartet wird. Beenden ist ja kein Problem, die Break-Funktion dann schön komfortabel in einem Forthwort.

Das sind die Sachen die mir so ganz spontan einfallen, sollte problemlos machbar sein. Am einfachsten ist wahrscheinlich Variante 2, da man da alles bequem unter Forth testen kann - sowas ist ja immer eine Stärke von Forth.

[/quote]

Variante 2 geht, aber die Zeit zwischen dem Break und der neuen Zeichenausgabe wird ganz schön lange, außerdem find ich Version 1 etwas sauberer.

Grüße

Markus

[drohne235]

Wie kann ich meherer AsCII zeichen zu einem Cstr zusammenbasteln und dann mit cogx ausgeben?

Kann es grad nicht testen, aber könnte etwa so funktionieren:

: myString c" abc" ;

Reserviert einen ausreichend langen CString im Wörterbuch. Die Zeichen in dem String sind dabei quasi nur Platzhalter. Ruft man myString auf, bekommt man die Anfangsadresse des Strings auf dem Stack. Da es ein counted-string ist, befindet sich im ersten Byte die Stringlänge, was in meinen Augen wesentlich eleganter als ein 0-term-String ist, bei welchem man immer erst die Länge auszählen muß.

Mit folgendem Wort kann man nun in diesem String beliebige Zeichen zusammensetzen:

: setSeq1
myString
1+ dup 01 C!
1+ dup 05 C!
1+ 00 C! ;

setSeq1 sollte "abc" also mit $01 $05 $00 überschreiben. Man muss natürlich selbst aufpassen, dass man die Stringgrenze nicht überschreibt,sonst beschädigt man das folgende Wort im Wörterbuch! Wenn man möchte, kann man sich bei Bedarf natürlich auch Worte definieren, welche solche Fehler abfangen.

myString .cstr \ Ausgabe des Strings
myString 2 cogx \ String über die I/O-Pipe zu Cog 2 senden

Schau mal ob das so funktioniert.

[MarkusG]

So hier wie versprochen der modifizierte code um ein Break auszugeben

Ganz am Anfang des Assemblerbereiches von PropForth.spin steht der
Asemby language serial driver
serentryPFA ist das label . Hier eine kleine Änderung inn der Transmit Routine

Code: Alles auswählen

' Transmit
'
transmit                jmpret  task1Ptr, task2Ptr
                        rdword  txdata, v_in

                        cmp     txdata, #$000 wz   'oo generates a break

        if_z            jmp     #:sbreak 
                        
                        test    txdata, #$100 wz   ' wz is 1 if all bit after AND are 0 -> sending data if bit 8 is not set
                        
        if_nz           jmp     #transmit

                                                 
                        mov     t1 , #$100
                        wrword  t1 , v_in        ' write $100 back to addres V_in

                        or      txdata,#$100     ' add start and stopbit
                        shl     txdata,#2
                        or      txdata,#1
                        mov     txbits,#11
                        mov     txcnt,cnt         ' cnt = system counter
                        jmp     #:bit

:sbreak                  mov     t1 , #$100
                        wrword  t1 , v_in        ' write $100 back to addres V_in

                        mov     txdata, #$1   ' write 1 to Txdata
                        shl     txdata, #32     ' shift left 1 to %10000000000000000000000000000000
                        sar     txdata, #32     ' shift arithmetic right to get $FFFFFFFF, is there any better way to get this result?
                        
                        mov     txbits, #32     ' reduce this number to get a shorter break now its 32 marks/spaces
                        mov     txcnt, cnt

Das mit dem Zusammenbauen eines Strings war eine gute Anregung

als

Code: Alles auswählen

: zeile c" xxx" ;
0 zeile 1+ C!

schreibt dann die 0 an die erste Stelles des strings ein bischen anders wie dein Vorschlag.

Um das CRLF bei der ausgabe über
c" test" 2 cogx

zu unterdrücken hab ich das cogx als cogwocrlf definiert und dabei das cr weggelassen also

Code: Alles auswählen

\ das Original
: cogx io 2+ W@ rot2 cogio io 2+ W! .cstr cr io 2+ W! ;   

\ ohne CRLF
: cogwocrlf  io 2+ W@ rot2 cogio io 2+ W! .cstr io 2+ W! ;   

Jetzt gehts weiter mit der Verarbeitung ankommender Zeichen...

Grüße

Markus

[MarkusG]

Hallo,

mal ne ganz banale Frage

decimal
65 emit

gibt A aus ok.

wenn ich jetzt A auf den Stack legen möchte (also 65) einfach der Lesbarkeit halber
'A' oder
A char

oder muss ich eine Konstante definieren?

Hab die beide Brodie Bücher und einiges aus dem web und die Befehlsliste von PropForth und bin nach wie vor etwas verwirrt ...

Grüße

Markus

[MarkusG]

So jetzt habe ich mein kleines Projekt mal hierhergestellt.
Will man irgendwelche Kommanos send und Messdaten o.ä. holen, dann ist das ein Grundgerüst das bei mir funktioniert
Entscheidend ist eigentlich
solcomopen und solinput, vorher muss man noch ein x cogstop und x x x x startserialcog machen
Das ganze geht auf ein posting von SalS zurück, un den Interpreationen von caskaz

Code: Alles auswählen

fl

\ I like to send some command to any serialport and receive some answers from this port
\ the answer should be shown on the console
\ this is a very common task in any kind of instrumentation
\ herer its a RS422 port
\
\ i have addd modified the PropForth.spin a little bit to create an odd parity serial signal
\ and also to create a break signal  (12 bits low) which is genaerated if i am sending 0x7C
\  



\ a place for the output of the serial driver

hex
wvariable inchar 100 inchar W!


decimal
\ defining the con nr. for the comicating cog
2       wconstant            orbitcog

\ defining the io pins for the instrument
5       wconstant      orbitrxpin
4               wconstant            orbittxpi
6               constant             orbitresetpin


\ defining the baudrate for the instrument
9600    wconstant      orbitbaudrate


\ serial no. of 2 instruments each 10 chars

: orbits c" 130B520P01130B520P02" ;


orbitcog cogstop

orbitrxpin orbittxpin orbitbaudrate orbitcog startserialcog
10 delms

\ es wird ein cogw definiert wie cogx nur ohne cr


decimal

\ not used anymore = cogx without crlf : cogw io 2+ W@ rot2 cogio io 2+ W! .cstr io 2+ W! ;




\ RS422 direction switch 

: ausgang orbitresetpin pinout ;
: aus orbitresetpin pinhi ;
: ein orbitresetpin pinlo ;


hex


\all following words are using hexadecimal constants

7C wconstant    w_strich
52 wconstant    w_R
4E wconstant    w_N
49 wconstant    w_I     
31 wconstant    w_1
53 wconstant    w_S


: send
   aus
   emit
   1 delms
   ein
   1 delms
;


: sendbreak
        aus
  w_strich emit
        2 delms
  ein
;

: solinit
  ausgang
  sendbreak
  1 delms
  w_R send
  1 delms
  0 send
  1200 delms
;


: solnotify
        sendbreak
        2 delms
        w_N send
        2 delms
        0 send
;




: solsetaddr
\ (index -) give 1..x index of the orbit code in orbits
\ calculate the index of the string
\ attention * is only in the Propforth.f !
  sendbreak
  1 delms
  w_S send
  1 delms
  dup
  send
  1 delms
  1-
        B *
        orbits
        1+
\ the address of the string on the stack        
        swap +
\ swap the index and the address and add the index
        aus
        A
\ give out 10 signs     
        .str
        4 delms
        ein
        0 send
;       


        
: solident
  sendbreak
  1 delms
  w_I send
  1 delms
  1 send
;

: solread
\ (index - ) 
        sendbreak
        1 delms
        w_1 send
        send
;


\ this is the core of everything
\ solcomopen redirets the output of the forth console two the serialcog started above
\ an emit is now sending to another serial interface
\ all bytes received are stored in the serial input buffer of the orbitcog
\these code was published by SalS in the Propeller Forum
        
fl
: solcomopen

\ get the current output ptr of orbitcog, leave on the stack
    orbitcog cogio 2+ W@
\ set the output of orbitcog to point to inchar   
    inchar orbitcog cogio 2+ W!
\ get the current output ptr of this cog, leave on the stack
    io 2+ W@
\ set the output ptr of this cog to the input of orbitcog
    orbitcog cogio io 2+ W!
;


\ now read out the iputbuffer of orbitcog to the console

: solinput
hex
\ input no. of bytes to read
\ restore this cogs output pointer
    io 2+ W!
\ the serial port buffers up to 128 characters on input, so they should all be there
    F 0
    do
        i .
\ poll for a char, 4096 times max
        1000 0
        do
\ is there a character from the serial port
            inchar W@ 100 and 0=
            if
\ get the char
                inchar W@
\ set inchar ready to receive next char
                100 inchar W!
                .
                leave
            then
        loop
        cr
    loop
\ STILL BIG question: not clear what this should do???
\    orbitcog cogio 2+ W!
;



: orbitinit
        solcomopen
        1 delms
        solinit
        2 delms
        solinput
;


: orbitsetaddr
        solcomopen
        1 delms
        1 solsetaddr
        2 delms
        solinput
;


: orbitread
        solcomopen
        1 delms
        1 solread
        2 delms
        solinput
;