PicoRAM Ultimate Rev. 2

Assembled one of the blue PCBs by now - I really love the look of it! 

https://www.hackster.io/news/michael-wessel-s-picoram-ultimate-vintage-sbc-expansion-doubles-its-ram-emulation-to-a-generous-4kb-17457264a079
Only seeing this now... 9 days later... 

... well, it wasn't easy and required a lot of stubbornness and perseverance on my side. Several of Sonnet's high-level "thinking" errors / road blocks needed to be overcome first. But once I pointed out that it needed to use SIGNED multiplication for the main iteration loop, and UNSIGNED multiplication for the coordinate transformations, everything finally fell into place. From the basic B&W Appleman it then created this dithered / shaded version - flawless in one attempt, no errors. Now, there certainly isn't that much MC-6800 assembly code out there in the training data... after all, this CPU is from 1974 (!), and my ET-3400 from 1977. I just entered first grade in 1977. Also, the situation is not comparable to Python at all, and testing is entirely manual. It had to rely on textual input from me, the "human interface", operating the ET-3400. It hence had to create test cases, ask me for test case results, re-iterate for fixing bugs, etc. I am impressed that it was able to do that. It certainly needs strong supervision for use cases such as this. But I can easily see that this could work fully autonomously with a bunch of agents (one agent playing the role of me, the supervisor and high-level guidance giving agent, one testing agent, etc.) and proper tool access. A storm is coming! I believe the days of stochastic parroting and regurgitating are finally over, and that these models are becoming increasingly useful for non-trivial, real-world programming tasks. Note that assembly is REALLY HARD. You need to understand every instruction down to the level of INDIVIDUAL BITS, AND know all the side effects. Reasoning over states and side effects is notoriously difficult, yet Sonnet succeeded. Wow.

... as always, it took a bit of trial & error, and Copilot didn't get it right until I supplied the following hint: 

Hence, previous attempts looked like this:

;
; Largely written by Copilot, with some help by Michael Wessel
; 2/12/2026 (i.e., to get the display "shearing" right - it was stuck there)
;

; =========================================================
; Firmware ROM Routines (ET‑3400 Monitor)
; =========================================================

RESET       = $FC00
INCH        = $FDF4
ENCODE      = $FDBB
OUTCH       = $FE3A
OUTHEX      = $FE28
OUTBYT      = $FE20
OUTST1      = $FE50
OUTST0      = $FD8D
DSPLAY      = $FD7B
REDIS       = $FCBC


; =========================================================
; ET‑3400 + 128×32 OLED
; Sierpinski fractal using logical coordinates (LX, LY)
; Display shear applied only during plotting:
;
;     ScreenX = LX + (LY >> 1)
;     ScreenY = LY
;
; This preserves the pure Sierpinski logic (LX & LY == 0)
; while visually tilting the triangle on the OLED.
;
; Variables at $0100, code at $1000
; =========================================================

            ORG   $0100

; -----------------------------
; Logical fractal coordinates
; -----------------------------
LX:         RMB   1      ; logical X coordinate
LY:         RMB   1      ; logical Y coordinate

; -----------------------------
; Screen coordinates (after shear)
; -----------------------------
SX:         RMB   1      ; screen X = LX + (LY >> 1)
SY:         RMB   1      ; screen Y = LY

COL:        RMB   1      ; pixel color (0xFF = on)


; -----------------------------
; Temporary scratch
; -----------------------------
T1:         RMB   1      ; holds LY >> 1


; =========================================================
; CODE SECTION
; =========================================================
            ORG   $1000


; ---------------------------------------------------------
; MAIN — Sierpinski in logical space, sheared only in plotting
; ---------------------------------------------------------
MAIN:
            JSR   CLEARSCREEN
            JSR   INCH

            CLR   LY          ; start at logical Y = 0

Y_LOOP:
            CLR   LX          ; start each row at logical X = 0

X_LOOP:
; ---------------------------------------------------------
; Sierpinski test in logical space:
;     (LX & LY) == 0  → pixel is part of the fractal
; ---------------------------------------------------------
            LDAA  LX
            ANDA  LY
            BNE   SKIP_PLOT   ; if nonzero → skip pixel

; ---------------------------------------------------------
; Compute screen coordinates:
;
;   SX = LX + (LY >> 1)
;   SY = LY
;
; This applies a gentle shear to the right, visually
; turning the square-grid Sierpinski into a triangular one.
; ---------------------------------------------------------
            LDAA  LY
            LSRA               ; LY >> 1
            STAA  T1           ; T1 = LY/2

            LDAA  LX
            ADDA  T1           ; SX = LX + (LY/2)
            STAA  SX

            LDAA  LY
            STAA  SY           ; SY = LY

; ---------------------------------------------------------
; Plot pixel at (SX, SY)
; ---------------------------------------------------------
            LDAA  #$FF
            STAA  COL
            JSR   PLOTNU       ; your non-updating plot routine

SKIP_PLOT:
; ---------------------------------------------------------
; Advance logical X
; ---------------------------------------------------------
            INC   LX
            LDAA  LX
            CMPA  #128
            BCS   X_LOOP       ; continue while LX < 128

; ---------------------------------------------------------
; Advance logical Y
; ---------------------------------------------------------
            INC   LY
            LDAA  LY
            CMPA  #32
            BCS   CONT         ; continue while LY < 32

; ---------------------------------------------------------
; Finished — start over after keypress
; ---------------------------------------------------------
DONE:
            JSR INCH
	    JSR MAIN

; ---------------------------------------------------------
; End-of-row housekeeping
; ---------------------------------------------------------
CONT:
            JSR   PLOT         ; your update/refresh routine
            BCS   Y_LOOP       ; branch always (BCS always true after JSR)


; ---------------------------------------------------------
; CLEARSCREEN
; ---------------------------------------------------------
CLEARSCREEN:
        PSHA
        LDAA  #$00
        JSR   EXEC
        PULA
        
        JSR LDELAY
        JSR LDELAY 
        
        RTS


; ---------------------------------------------------------
; PLOTNU — high-level plot using EXEC, NO UPDATE
; ---------------------------------------------------------
PLOTNU:
        LDAA  #$0A
        JSR   EXEC

        LDAA  sx
        JSR   EXEC

        LDAA  sy
        JSR   EXEC

        LDAA  col
        JSR   EXEC

        JSR   DELAY
        RTS


; ---------------------------------------------------------
; PLOT — high-level plot using EXEC, WITH SCREEN UPDATE
; ---------------------------------------------------------
PLOT:
        LDAA  #$0B
        JSR   EXEC

        LDAA  sx
        JSR   EXEC

        LDAA  sy
        JSR   EXEC

        LDAA  col
        JSR   EXEC

        JSR   LDELAY
        RTS


; ---------------------------------------------------------
; PLOT0 — disp pixel output
; ---------------------------------------------------------
PLOT0:
        JSR   REDIS

        LDAA  sx
        JSR   OUTBYT

        LDAA  sy
        JSR   OUTBYT

        LDAA  col
        JSR   OUTBYT

        RTS


; ---------------------------------------------------------
; EXEC — write A to $1800 with timing
; ---------------------------------------------------------
EXEC:
        NOP
        NOP
        NOP
        NOP
        NOP
        NOP
        NOP

        STAA  $1800

        NOP
        NOP
        NOP
        NOP
        NOP
        NOP
        NOP

        NOP
        NOP
        NOP
        NOP
        NOP
        NOP
        NOP
        JSR   DELAY

        RTS


; ---------------------------------------------------------
; DELAY — coarse delay
; ---------------------------------------------------------
DELAY:
        PSHA
        PSHB

        LDAA  #$01
OUTER:  LDAB  #$FF

INNER:  DECB
        BNE   INNER

        DECA
        BNE   OUTER

        PULB
        PULA
        RTS


; ---------------------------------------------------------
; LDELAY — longer delay
; ---------------------------------------------------------
LDELAY:
        PSHA
        PSHB

        LDAA  #$05
LOUTER: LDAB  #$FF

LINNER: DECB
        BNE   LINNER

        DECA
        BNE   LOUTER

        PULB
        PULA
        RTS

Thanks to CoPilot, who wrote 80% of the code, a piece of non-trivial MC-6800 no longer takes hours to code, but can be implemented in 2 hours on a Sunday morning before breakfast: 

... stay tuned for the graphical version soon... 

... making progress. Hoping to have Mandebrot Fractals soon, but will need to find MC6800 floating point routines. Anybody has some handy? Please contact me!

Aren't they beautiful? I think the blue is a good match! 

Revision 2 and version 2 firmware online: 

https://github.com/lambdamikel/picoram-ultimate 

Demo video: 

4 KB ROM emulation:

4 KB RAM emulation:

Revision 2 that fixes the /RE pin header layout flaw is working: 

Also, I extended the RAM emulation to 4 KBs (!) - shown with a decoder config from 0x0000 to 0x0fff here. 

When I built it I also encountered an issue with 74LS373 chips - turns out not all TTL LS latches were created equally... some troubleshooting advice for PicoRAM builders is in this video: