HIVE-Project

drohne235 hat geschrieben:UTF8/16: Jo, UTF8 fände ich auch deutlich besser.

\o/

drohne235 hat geschrieben:Ich bin mir auch nicht sicher, wo das herkommt?

Das Parallax-sche Spin-Tool (Propeller-Tool?) hat das als als Kodierung erkoren. Ich hab keine Idee, wie man auf diese Planke kommt...

drohne235 hat geschrieben: Muss ich unter Win erstmal nach einem Konverter schauen und bei der nächsten Version ändern.

Bei Windows kann ich nicht helfen... ich hab eben alles was auf ".spin" endet einmal (in einer 32bittigen VM) mit BST geladen und damit als UTF8 gespeichert. Ein sauberes Konverterskript bauen hätte im Zweifel deutlich länger gedauert und mit meinem auf ICONV basierenden Helferlein hätte ich auch hinterher alle Files anschauen/kontrollieren müssen...

drohne235 hat geschrieben: Habs mir auf die Liste geschrieben.

Zu den anderen Dateien (".lib", ".mod", ...) wär auch noch wichtig zu wissen, welche davon welche Zeilenenden haben dürfen/müssen. Wo ist CR, LF oder CRLF Pflicht, wo darf auch CR oder LF alleine benutzt werden?

drohne235 hat geschrieben: Hivebook/Hive Buch: Nee, der Hivebook ist nur der Name von meinem alten Notebook, mit welchem ich im Arbeitszimmer programmiere. Aber ein Kompendium wäre eine schöne Sache. "Hive intern" :) LOL. Denkbar wäre ein Wiki oder eine andere koperative Informationssammlung.

Wir landen immer wieder bei GitLab oder GitHub... Codeverwaltung, Wiki (auch unter Versionskontrolle), ...

Ich hab heute Mittag versucht, nach langer Pause mal wieder was mit Git zu aktualisieren... grausam... wieder fast Alles zu Git vergessen... es tut echt weh... aber es scheint alternativlos... :-(
***Merkel-Karo-mach...***

drohne235 hat geschrieben:Ein Wiki haben wir ja schon, aber der Inhalt ist mittlerweile etwas obsolet und bei den Exportmöglichkeiten kenne ich micht aus.

DokuWiki speichert die Texte im Filesystem als Dateien (im Gegensatz zu anderen Wikis, die Datenbanken oder VersionsControlSysteme benutzen), da sollte man leicht rankommen.

So, damit es hier auch niemand verpasst, wieder zwei neue Videos:

1. Tekromantische Heiligung des RasPi:

https://youtu.be/ZkPaYOuIjFY

2. Ich habe mal wieder angefangen, einen Editor zu programmieren...

https://youtu.be/xgEI_yVUXMk

Die Motivation dafür reicht immer etwa ein Wochenende oder zwei. Mal schauen, wie es dieses mal wird. Ich dachte mir, mit solchen kurzen "Update" Folgen schiebe ich immer mal kleine Fragmente rein - kein großer Aufwand, wird einfach nebenher mal ein paar Minuten eingesprochen auch die Videoschneiderei beschränkt sich dank fertigem Intro/Outro auf ca. 20 Minuten.

Ach ja, wie findet ihr das Tekromant-Outro?

Das Outro ist cool - schön technisch mit dem Quellcode. Allerdings eine kleine "Idee" zu lang. Vielleicht kürzt du es noch etwas ein und eine Überblendung zum Realbild oder Fade to Black, wäre noch eine Idee. Das Outro kam doch sehr plötzlich (trotz der bereits beginnenden Abspannmusik)...

Gruß,
Eric

ShiaPrime hat geschrieben:Das Outro kam doch sehr plötzlich (trotz der bereits beginnenden Abspannmusik)...

"Outro"... jetzt(!!!) hab ich's kappiert... dem "Intro" sein Gegenstück... und das hat nix mit "Outing" zu tun... boaaaah, hab ich gegrübelt...

yeti hat geschrieben:
ShiaPrime hat geschrieben:Das Outro kam doch sehr plötzlich (trotz der bereits beginnenden Abspannmusik)...
"Outro"... jetzt(!!!) hab ich's kappiert... dem "Intro" sein Gegenstück... und das hat nix mit "Outing" zu tun... boaaaah, hab ich gegrübelt...

Naja, jetzt wo du es sagst: man kann es auch mein Outing nennen.

die editor idee ist geil, drohne235

an dem ding solltest du weiter arbeiten. fehlt nur noch ein spin/asm compiler nativ auf dem hive

Ein SPIN Compiler kann ganz schön komplex werden ob da der Speicher reicht?
Einfacher sieht es da bei PASM aus.
Da steht nur die Frage nach der Formatierung des Quelltextes.

Grundsätzlich würde ich pro Codezeile eine Feste Länge vorsehen.
Das vereinfacht die Speicherverwaltung beim Editieren.
Eventuell währe das dann auch in PASM machbar.

Ein Reassembler währe nicht das Problem.

PIC18F2550 hat geschrieben:Ein SPIN Compiler kann ganz schön komplex werden ob da der Speicher reicht?

Er reicht.
Zwei existierende auf dem Propeller laufende Spin-Compiler beweisen dies.

PIC18F2550 hat geschrieben:Einfacher sieht es da bei PASM aus.

Interessant ist der Ansatz des Spincompilers in Spinix: Er Kompiliert Spin nach SPASM (der Bytecode der SpinVM als Assemblerbefehle).

Leider sind SPASM, SPINIT und die Helferlein drumrum in C geschrieben und werden durch einen C->Spin-Überstzer gejagt. Das portieren zu wollen grenzt an selbstschädigendes Verhalten und bringt einen der Zwangseinweisung vermutlich bedrohlich nah...

Der Spincompiler von Sphinx ist direkt in Spin geschrieben aber auch ein Brocken, den man nicht mal eben portiert bekommt.

Der schnelle Quickhack für zwischen ausm Bett fallen und wach werden ist wohl der PI-Zero (oder Mitbewerber) als an den Hive geschweißter Coprozessor. Hierauf könnten OpenSpin und Spin2CPP (also auch FastSpin) nativ laufen und HomeSpun (in Mono) und BSTC (via Qemu)...

Vom Preis-Wumm-Verhältnis sind die OrangePI-Zero (Quadcore, 512M RAM) interessanter als der PI-Zero und diese sind auch in Stückzahlen erhältlich. Die PI-Macher spielen ja noch immer das PI-Zero-Verknappungs-Spiel (nur ein PI-Zero pro Bestellung!) und ich weigere mich, irgendwas mit PI-Zero zu machen, solange sich dies nicht ändert. Aber die OrangePIs sind irgendwie auch Gammel. Der WiFi-Treiber mancher OPIs ist Schrott, manch Board überhitzt und irgendwo hieß es, daß der OPI-Support sich auf das reine Verkaufen beschränkt. Zum Thema ARM-Beiwagen am Hive ist also noch viel zu forschen...

yeti hat geschrieben:Zwei existierende auf dem Propeller laufende Spin-Compiler beweisen dies.

Link zum Quellcode bitte......

Sonst muss ich hier weiter machen..

Code: Alles auswählen

CON
  _clkmode = XTAL1|PLL16X
  _xinfreq = 5_000_000

  CODE       = %0000_0001
  CODE_ERROR = %0000_0010
  CODE_J_C   = %0000_0100
  CODE_R     = %0000_1000
  CODE_M     = %0001_0000
VAR
long Ccod[512]
byte Cmark[512]  ' Status der Zelle (unbenutzt | CODE | CODE_ERROR | Marke_JMP_CALL_RET | modifizierter Code)
word Rstack[512] ' Hier werden die noch abzuarbeideten Adressen gespeichert

DAT
  byte  "NOP     "
  byte  "WRBYTE  "
  byte  "RDBYTE  "

PUB MAIN
    REASM


PRI REASM | ad, sp, ci, i, cc, cd, cs
  repeat i from 0 to 511
    Cmark[i]    := $0
    Rstack[i*2] := $FFFF

' code zerlegen 1. Lauf (Ermittlung Marken/CODE...)
  Rstack[0] := $0          ' Startadresse COG
  sp        := 1           ' Stackmax
  ad        := -1
  repeat Rstack[0] <> $FFFF
    if ad := -1     ' keine Adresse
      ad := Rstack[0]
      wordmove(@Rstack, (@Rstack+2), 510)     ' Blockmove -1 word ( eine Adresse vom Stabel geholt)
      Rstack[511] := $FFFF
      sp--
    if ad == $FFFF  ' alles abgearbeitet
      quit         ' repeat exit fertig zur ausgabe
    else
      ci := i := cc := cd := cs := Ccod[ad*4]
      ci := (ci > 22) & %1111111111
       i := ( i > 22) & %0000000001 ' Lower case “i” denotes a bit that is affected by immediate status
      cc := (cc > 18) & %0000001111
'      cd := (cd >  9) & %0111111111
      cs :=  cs       & %0111111111
      if Cmark[ad] <> 0
        next  ' Bereits bearbeitet
      else
        if cc == %0000                    ' NOP
          ad++
        else
          case ci
            %000000_0000, %000000_0001 :  ' WRBYTE
                ad := ad_code(ad)
            %000000_0010, %000000_0011 :  ' RDBYTE
                ad := ad_code(ad)
            %000001_0000, %000001_0001 :  ' WRWORD
                ad := ad_code(ad)
            %000001_0010, %000001_0011 :  ' RDWORD
                ad := ad_code(ad)
            %000010_0000, %000010_0001 :  ' WRLONG
                ad := ad_code(ad)
            %000010_0010, %000010_0011 :  ' RDLONG
                ad := ad_code(ad)
            %000011_0000, %000011_0001, %000011_0011 :  ' HUBOP ???
                cs := cs & %111           ' Restliche Bits löschen
                case cs
                    %001 :  ' COGID
                        ad := ad_code(ad)
                    %010 :  ' COGINIT
                        ad := ad_code(ad)
                    %011 :  ' COGSTOP
                        ad := ad_code(ad)
                    %100 :  ' LOCKNEW
                        ad := ad_code(ad)
                    %101 :  ' LOCKRET
                        ad := ad_code(ad)
                    %110 :  ' LOCKSET
                        ad := ad_code(ad)
                    %111 :  ' LOCKCLR
                        ad := ad_code(ad)
            %001000_0010, %001000_0011 :  ' ROR
                ad := ad_code(ad)
            %001001_0010, %001001_0011 :  ' ROL
                ad := ad_code(ad)
            %001010_0010, %001010_0011 :  ' SHR
                ad := ad_code(ad)
            %001011_0010, %001011_0011 :  ' SHL
                ad := ad_code(ad)
            %001100_0010, %001100_0011 :  ' RCR
                ad := ad_code(ad)
            %001101_0010, %001101_0011 :  ' RCL
                ad := ad_code(ad)
            %001110_0010, %001110_0011 :  ' SAR
                ad := ad_code(ad)
            %001111_0010, %001111_0011 :  ' REV
                ad := ad_code(ad)
            %010000_0010, %010000_0011 :  ' MINS
                ad := ad_code(ad)
            %010001_0010, %010001_0011 :  ' MAXS
                ad := ad_code(ad)
            %010010_0010, %010010_0011 :  ' MIN
                ad := ad_code(ad)
            %010011_0010, %010011_0011 :  ' MAX
                ad := ad_code(ad)
            %010100_0010, %010100_0011 :  ' MOVS
                ad := ad_code(ad)
            %010101_0010, %010101_0011 :  ' MOVD
                ad := ad_code(ad)
            %010110_0010, %010110_0011 :  ' MOVI
                ad := ad_code(ad)
            %010111_0000               :  ' JMP
                ad := ad_code(ad)
                ad := cs
            %010111_0001               :  ' JMP/RET
  '          %010111_0001               :  ' RET
                ad := ad_code(ad)
            %010111_0010               :  ' JMPRET
                ad := ad_code(ad)
            %010111_0011               :  ' JMPRET/CALL
  '          %010111_0011               :  ' CALL
                ad := ad_code(ad)
            %011000_0000, %011000_0001 :  ' TEST
                ad := ad_code(ad)
            %011000_0010, %011000_0011 :  ' AND
                ad := ad_code(ad)
            %011001_0000, %011001_0001 :  ' TESTN
                ad := ad_code(ad)
            %011001_0010, %011001_0011 :  ' ANDN
                ad := ad_code(ad)
            %011010_0010, %011010_0011 :  ' OR
                ad := ad_code(ad)
            %011011_0010, %011011_0011 :  ' XOR
                ad := ad_code(ad)
            %011100_0010, %011100_0011 :  ' MUXC
                ad := ad_code(ad)
            %011101_0010, %011101_0011 :  ' MUXNC
                ad := ad_code(ad)
            %011110_0010, %011110_0011 :  ' MUXZ
                ad := ad_code(ad)
            %011111_0010, %011111_0011 :  ' MUXNZ
                ad := ad_code(ad)
            %100000_0010, %100000_0011 :  ' ADD
                ad := ad_code(ad)
            %100001_0000, %100001_0001 :  ' CMP
                ad := ad_code(ad)
            %100001_0010, %100001_0011 :  ' SUB
                ad := ad_code(ad)
            %100010_0010, %100010_0011 :  ' ADDABS
                ad := ad_code(ad)
            %100011_0010, %100011_0011 :  ' SUBABS
                ad := ad_code(ad)
            %100100_0010, %100100_0011 :  ' SUMC
                ad := ad_code(ad)
            %100101_0010, %100101_0011 :  ' SUMNC
                ad := ad_code(ad)
            %100110_0010, %100110_0011 :  ' SUMZ
                ad := ad_code(ad)
            %100111_0010, %100111_0011 :  ' SUMNZ
                ad := ad_code(ad)
            %101000_0010, %101000_0011 :  ' MOV
                ad := ad_code(ad)
            %101001_0010, %101001_0011 :  ' NEG
                ad := ad_code(ad)
            %101010_0010, %101010_0011 :  ' ABS
                ad := ad_code(ad)
            %101011_0010, %101011_0011 :  ' ABSNEG
                ad := ad_code(ad)
            %101100_0010, %101100_0011 :  ' NEGC
                ad := ad_code(ad)
            %101101_0010, %101101_0011 :  ' NEGNC
                ad := ad_code(ad)
            %101110_0010, %101110_0011 :  ' NEGZ
                ad := ad_code(ad)
            %101111_0010, %101111_0011 :  ' NEGNZ
                ad := ad_code(ad)
            %110000_0000, %110000_0001 :  ' CMPS
                ad := ad_code(ad)
            %110001_0000, %110001_0001 :  ' CMPSX
                ad := ad_code(ad)
            %110010_0010, %110010_0011 :  ' ADDX
                ad := ad_code(ad)
            %110011_0000, %110011_0001 :  ' CMPX
                ad := ad_code(ad)
            %110011_0010, %110011_0011 :  ' SUBX
                ad := ad_code(ad)
            %110100_0010, %110100_0011 :  ' ADDS
                ad := ad_code(ad)
            %110101_0010, %110101_0011 :  ' SUBS
                ad := ad_code(ad)
            %110110_0010, %110110_0011 :  ' ADDSX
                ad := ad_code(ad)
            %110111_0010, %110111_0011 :  ' SUBSX
                ad := ad_code(ad)
            %111000_0010, %111000_0011 :  ' CMPSUB
                ad := ad_code(ad)
            %111001_0010, %111001_0011 :  ' DJNZ
                ad := ad_code(ad)
            %111010_0000, %111010_0001 :  ' TJNZ
                ad := ad_code(ad)
            %111011_0000, %111011_0001 :  ' TJZ
                ad := ad_code(ad)
            %111100_0000, %111100_0001 :  ' WAITPEQ
                ad := ad_code(ad)
            %111101_0000, %111101_0001 :  ' WAITPNE
                ad := ad_code(ad)
            %111110_0010, %111110_0011 :  ' WAITCNT
                ad := ad_code(ad)
            %111111_0000, %111111_0001 :  ' WAITVID
                ad := ad_code(ad)




            other : ' ERROR
' alle Adressen abgearbeitet
' code zerlegen 2. Lauf (ausgabe linear)
    repeat ad from 0 to 511
    ci := i := cc := cd := cs := Ccod[ad*4]
    ci := (ci > 22) & %1111111111
     i := ( i > 22) & %0000000001 ' Lower case “i” denotes a bit that is affected by immediate status
    cc := (cc > 18) & %0000001111
    cd := (cd >  9) & %0111111111
    cs :=  cs       & %0111111111
    if (Cmark & %0100_0000) == %0100_0000 ' CODE
      if cc == %0000                    ' NOP
      else
        case ci
          %000000_0000, %000000_0001 :  ' WRBYTE
          %000000_0010, %000000_0011 :  ' RDBYTE
          %000001_0000, %000001_0001 :  ' WRWORD
          %000001_0010, %000001_0011 :  ' RDWORD
          %000010_0000, %000010_0001 :  ' WRLONG
          %000010_0010, %000010_0011 :  ' RDLONG
          %000011_0000, %000011_0001, %000011_0011 :  ' HUBOP ???
              case cs
                  %001 :  ' COGID
                  %010 :  ' COGINIT
                  %011 :  ' COGSTOP
                  %100 :  ' LOCKNEW
                  %101 :  ' LOCKRET
                  %110 :  ' LOCKSET
                  %111 :  ' LOCKCLR
          %001000_0010, %001000_0011 :  ' ROR
          %001001_0010, %001001_0011 :  ' ROL
          %001010_0010, %001010_0011 :  ' SHR
          %001011_0010, %001011_0011 :  ' SHL
          %001100_0010, %001100_0011 :  ' RCR
          %001101_0010, %001101_0011 :  ' RCL
          %001110_0010, %001110_0011 :  ' SAR
          %001111_0010, %001111_0011 :  ' REV
          %010000_0010, %010000_0011 :  ' MINS
          %010001_0010, %010001_0011 :  ' MAXS
          %010010_0010, %010010_0011 :  ' MIN
          %010011_0010, %010011_0011 :  ' MAX
          %010100_0010, %010100_0011 :  ' MOVS
          %010101_0010, %010101_0011 :  ' MOVD
          %010110_0010, %010110_0011 :  ' MOVI
          %010111_0000               :  ' JMP
          %010111_0001               :  ' JMP/RET
'          %010111_0001               :  ' RET
          %010111_0010               :  ' JMPRET
          %010111_0011               :  ' JMPRET/CALL
'          %010111_0011               :  ' CALL
          %011000_0000, %011000_0001 :  ' TEST
          %011000_0010, %011000_0011 :  ' AND
          %011001_0000, %011001_0001 :  ' TESTN
          %011001_0010, %011001_0011 :  ' ANDN
          %011010_0010, %011010_0011 :  ' OR
          %011011_0010, %011011_0011 :  ' XOR
          %011100_0010, %011100_0011 :  ' MUXC
          %011101_0010, %011101_0011 :  ' MUXNC
          %011110_0010, %011110_0011 :  ' MUXZ
          %011111_0010, %011111_0011 :  ' MUXNZ
          %100000_0010, %100000_0011 :  ' ADD
          %100001_0000, %100001_0001 :  ' CMP
          %100001_0010, %100001_0011 :  ' SUB
          %100010_0010, %100010_0011 :  ' ADDABS
          %100011_0010, %100011_0011 :  ' SUBABS
          %100100_0010, %100100_0011 :  ' SUMC
          %100101_0010, %100101_0011 :  ' SUMNC
          %100110_0010, %100110_0011 :  ' SUMZ
          %100111_0010, %100111_0011 :  ' SUMNZ
          %101000_0010, %101000_0011 :  ' MOV
          %101001_0010, %101001_0011 :  ' NEG
          %101010_0010, %101010_0011 :  ' ABS
          %101011_0010, %101011_0011 :  ' ABSNEG
          %101100_0010, %101100_0011 :  ' NEGC
          %101101_0010, %101101_0011 :  ' NEGNC
          %101110_0010, %101110_0011 :  ' NEGZ
          %101111_0010, %101111_0011 :  ' NEGNZ
          %110000_0000, %110000_0001 :  ' CMPS
          %110001_0000, %110001_0001 :  ' CMPSX
          %110010_0010, %110010_0011 :  ' ADDX
          %110011_0000, %110011_0001 :  ' CMPX
          %110011_0010, %110011_0011 :  ' SUBX
          %110100_0010, %110100_0011 :  ' ADDS
          %110101_0010, %110101_0011 :  ' SUBS
          %110110_0010, %110110_0011 :  ' ADDSX
          %110111_0010, %110111_0011 :  ' SUBSX
          %111000_0010, %111000_0011 :  ' CMPSUB
          %111001_0010, %111001_0011 :  ' DJNZ
          %111010_0000, %111010_0001 :  ' TJNZ
          %111011_0000, %111011_0001 :  ' TJZ
          %111100_0000, %111100_0001 :  ' WAITPEQ
          %111101_0000, %111101_0001 :  ' WAITPNE
          %111110_0010, %111110_0011 :  ' WAITCNT
          %111111_0000, %111111_0001 :  ' WAITVID

' alle Adressen abgearbeitet

PRI ad_code(ad)
  Cmark[ad] := Cmark[ad] & CODE
  result := ++ad

PIC18F2550 hat geschrieben:
yeti hat geschrieben:Zwei existierende auf dem Propeller laufende Spin-Compiler beweisen dies.
Link zum Quellcode bitte......

Du hast es so gewollt:

SphinxOS und Sphinxcompiler
—▶ http://www.sphinxcompiler.com/
—▶ http://forums.parallax.com/discussion/1 ... at-upew/p1

Homespun
...ist vom selben Autor wie Sphinxcompiler und rennt unter DotNet bzw. Mono.
Vermutlich haben Homespun und Sphinxcompiler ein paar Gemeinsamkeiten unter der Haube und daher erschien mir seine Erwähnung hier zumindest nicht völlig falsch.
—▶ http://forums.parallax.com/discussion/1 ... -source/p1

Spinix mit SPASM, SPINIT & Co.
—▶ http://forums.parallax.com/discussion/123795/spinix/p1

HIVE-Project

Videos & Co.

Re: Videos & Co.

Re: Videos & Co.

Re: Videos & Co.

Re: Videos & Co.

Re: Videos & Co.

Re: Videos & Co.

Re: Videos & Co.

Re: Videos & Co.

Re: Videos & Co.

Re: Videos & Co.