HBasic

[PIC18F2550]

movs a, #$+1

Damit währe zu einem jmpret nur eine Marke und eine Marke_ret möglich.

z.B Sprung verteiler:

Code: Alles auswählen

loop
....

    mov b, #spv-1
    add b, befehl
    jmpret a, b
rt  jmp loop

spv jmp be1
    jmp be2
...

be1 .....
    ret   'nach rt

be2 .....
    ret   'nach rt

long a 0
long b 0

Das zeigt welches problem ich hab.

Ich könnte ja auch die variable a sichern und beim eintritt in bel1/2 neu setzen um so einen gemeinsamen rückkehrpunkt zu bekommen.

[kuroneko]

Koennte das hier funktionieren (fuer Deine Zwecke)?

http://forums.parallax.com/showthread.p ... ost1042052

[PIC18F2550]

sieht aus wie volltreffer werd's heute abend Testen.
Danke.

[PIC18F2550]

Leider nur auf dem 1. Blick.

ich müsste die RET's durch statische jmp ersetzen und diese würden bei einen jumpret von einer anderen Routine zerstört werden(ist im obrigen beispiel nicht enthalten sorry ).

Der Rücksprung müsste dann schon immer ein einfaches RET sein auch bei den vielen Rücksprüngen nach dem Sprungverteiler.

[kuroneko]

ich müsste die RET's durch statische jmp ersetzen und diese würden bei einen jumpret von einer anderen Routine zerstört werden ...

Versteh ich jetzt nicht. Das Beispiel (im Link) kommt mit normalen (single-use) ret insn aus. Macht also nichts wenn sie von anderen Routinen aufgerufen werden. Der einzige Knackpunkt vielleicht: Du benoetigst beide Adressen (label, label_ret) um die eigentliche jmpret insn zu fuettern. Selbst wenn Du auf index commands bestehst gibt's da 'ne Loesung, Problem ist dann aber die Einsprungtabelle (Speicherplatz).

Wenn ich Deine Code-Fragmente richtig interpretiere, hast Du also einen Befehls-Index (0..N) und willst die Funktion aber mit 'nem call aufrufen. Ist das so weit OK?

[PIC18F2550]

Ja das stimmt.

sowas wie call index in der Art.

ich könnte auch

Code: Alles auswählen

start
...
        jmp index
        call #sub1
        jmp #start
        call #sub2
        jmp #start
        call #sub3
        jmp #start
...

das würde bei index max = 64 --> 128 long's bedeuten.

Oder ich müsste die Runtime auf 32 kürzen (darauf wird es warscheinlich hinauslaufen).

[kuroneko]

Code: Alles auswählen

VAR
  long  storage
  
PUB null

  storage := TRUE
  cognew(@entry, @storage{0})
  repeat while storage

  vscl := cnt
  
  repeat
    exec(?vscl & %11)
    waitcnt(clkfreq/10 + cnt)
    
PRI exec(cmd)

  storage := NEGX|cmd
  repeat
  while storage
  
DAT             org     0

entry           jmpret  $, #setup

real            nop
done            wrlong  zero, par
idle            rdlong  code, par wz
        if_z    jmp     #$-1

                movs    temp, code
                andn    temp, #%1111111_00      ' 0..3
                add     temp, #table
                nop                             ' pipeline
temp            mov     real, 0-0
                jmp     %%0
                
table           call    #eins
                call    #zwei
                call    #drei
                call    #vier

' support code

eins            xor     outa, led0
eins_ret        ret

zwei            xor     outa, led1
                call    #eins
zwei_ret        ret

drei            xor     outa, led2
                call    #zwei
drei_ret        ret

vier            xor     outa, led3
vier_ret        ret

' initialised data and/or presets

mask            long    $00FF0000
led0            long    |< 23 | |< 16
led1            long    |< 22 | |< 17
led2            long    |< 21 | |< 18
led3            long    |< 20 | |< 19

' Stuff below is re-purposed for temporary storage.

setup           mov     dira, mask              ' demoboard LED bar
                jmp     %%0                     ' return

                fit
                
' uninitialised data and/or temporaries

                org     setup
                
code            res     1

                fit
                
CON
  zero = $1F0
  
DAT

[PIC18F2550]

Hi, kuroneko
Wenn ich dein Beispiel richtig verstehe brauche ich den Spinncode zur Laufzeit.
Leider ist nach dem start kein Spinn mehr aktiv.
Ich habe ich zu dieser Lösung entschieden.

Code: Alles auswählen

' ---------------------------------------------------------------------
TLOOP         wrlong    line,   areg         'neuen Linezeiger schreiben
' ---------------------------------------------------------------------
...
              mov       SPRV,   sprvm
              add       SPRV,   code
              shr       code,   #$6  wz      'untere 6 bit löschen
              sub       code,   #$0  wz      'Test ob richtiger 64 Token-block
        if_nz jmp       #RTLOOP              'wenn nicht dann rücksprung
SPRV          jmp       #SPRV0               '5C 7C 00 (1B+code)
SPRV0         jmp       #J00
...
J00   ' STOP
      ' Statusregister auf 1 setzen um IDE zu zeigen das ein STOP-Befehl empfangen wurde
      ' Zeilenregister zeigt auf nächste Zeile
              movs      JM00_ret,   #TLOOP
JM00          wrlong    h00000001,  stat
JM00_ret      ret

J00 ist einsprung vom Sprungverteiler
JM00 ist einsprung von externer routine über einen Call #JM00

Selbst wenn ich die runtime auf 64 befehle lasse kostet das mich gerade 64 longs und ich hätte immer noch 91 frei

Danke kuroneko die Informationen waren sehr hifreich.

[PIC18F2550]

Code: Alles auswählen

 Befehle runtime 00
  IO    TOKEN   Befehlsaufbau             Beschreibung
' ---------------------------------------------------------------------
  ja    $0000 = [code]                    STOP
' ---------------------------------------------------------------------
  ja    $0001 = [code]                    END
' ---------------------------------------------------------------------
        $0002 = [code][arg1]              GOTO
                arg1 : 16bit Adresse im hRAM
' ---------------------------------------------------------------------
        $0003 = [code][arg1]              Runtime-Kill
                arg1 : Runtimenummer 1-255, 0 ist nicht Löschbar
' ---------------------------------------------------------------------
        $0004 =
' ---------------------------------------------------------------------
        $0005 =
' ---------------------------------------------------------------------
        $0006 =
' ---------------------------------------------------------------------
        $0007 =
' ---------------------------------------------------------------------
        $0008 =
' ---------------------------------------------------------------------
        $0009 =
' ---------------------------------------------------------------------
        $000A =
' --------------------------------------------------------------------
        $000B =
' ---------------------------------------------------------------------
        $000C =
' ---------------------------------------------------------------------
        $000D =
' ---------------------------------------------------------------------
        $000E =
' ---------------------------------------------------------------------
        $000F =
' ---------------------------------------------------------------------
  ja    $0010 = [code][arg1][arg2][arg3]  write_Administra_word+long
  ja    $0020 = [code][arg1][arg2][arg3]  write_Bellatrix_word+long
' ---------------------------------------------------------------------
  ja    $0011 = [code][arg1][arg2][arg3]  write_Administra_byte+long
  ja    $0021 = [code][arg1][arg2][arg3]  write_Bellatrix_byte+long
' ---------------------------------------------------------------------
  ja    $0012 = [code][arg1][arg2]        write_Administra_long
  ja    $0022 = [code][arg1][arg2]        write_Bellatrix_long
' ---------------------------------------------------------------------
  ja    $0013 = [code][arg1][arg2]        write_Administra_byte+word
  ja    $0023 = [code][arg1][arg2]        write_Bellatrix_byte+word
' ---------------------------------------------------------------------
  ja    $0014 = [code][arg1]              write_Administra_word
  ja    $0024 = [code][arg1]              write_Bellatrix_word
' ---------------------------------------------------------------------
  ja    $0015 = [code][arg1]              write_Administra_byte
  ja    $0025 = [code][arg1]              write_Bellatrix_byte
' ---------------------------------------------------------------------
        $0016 = [code][arg1]              write_Administra_long    hRam Variabel_long
        $0026 = [code][arg1]              write_Bellatrix_long     hRam Variabel_long
' ---------------------------------------------------------------------
        $0017 = [code][arg1]              write_Administra_word    hRam Variabel_long
        $0027 = [code][arg1]              write_Bellatrix_word     hRam Variabel_long
' ---------------------------------------------------------------------
        $0018 = [code][arg1]              write_Administra_byte    hRam Variabel_long
        $0028 = [code][arg1]              write_Bellatrix_byte     hRam Variabel_long
' ---------------------------------------------------------------------
  *     $0019 = [code][arg1][arg2]        write_Administra_byte    eRam String 0 therminiert
  *     $0029 = [code][arg1][arg2]        write_Bellatrix_byte     eRam String 0 therminiert
' ---------------------------------------------------------------------
  *     $001A = [code][arg1][arg2][arg3]  write_Administra_byte    eRam String mit Länge
  *     $002A = [code][arg1][arg2][arg3]  write_Bellatrix_byte     eRam String mit Länge
' ---------------------------------------------------------------------
        $001B = [code][arg1]              read_Administra_long     hRam Variabel_long
        $002B = [code][arg1]              read_Bellatrix_long      hRam Variabel_long
' ---------------------------------------------------------------------
        $001C = [code][arg1]              read_Administra_word     hRam Variabel_long
        $002C = [code][arg1]              read_Bellatrix_word      hRam Variabel_long
' ---------------------------------------------------------------------
        $001D = [code][arg1]              read_Administra_byte     hRam Variabel_long
        $002D = [code][arg1]              read_Bellatrix_byte      hRam Variabel_long
' ---------------------------------------------------------------------
  *     $001E = [code][arg1][arg2]        read_Administra_byte     eRam String 0 therminiert
  *     $002E = [code][arg1][arg2]        read_Bellatrix_byte      eRam String 0 therminiert
' ---------------------------------------------------------------------
  *     $001F = [code][arg1][arg2]        read_Administra_byte     eRam String mit übertragener länge
  *     $002F = [code][arg1][arg2]        read_Bellatrix_byte      eRam String mit übertragener länge
' ---------------------------------------------------------------------

Die Bits 5&6 endscheiden ob es sich um:

%00000000_0000xxxx Algemeine Befehle
%00000000_0001xxxx Administra Befehle
%00000000_0010xxxx Bellatrix Befehle
%00000000_0011xxxx Administra Bellatrix DMA-Befehle

[kuroneko]

Wenn ich dein Beispiel richtig verstehe brauche ich den Spinncode zur Laufzeit.

Wenn Du damit das Beispiel aus meinem letzten Posting meinst dann hast Du etwas missverstanden. Der dort gelistete SPIN code ist nur fuer Demonstrationszwecke. Und was die Form der command loop angeht, auch nur ein Beispiel um den Befehl in code zu speichern.