Install-Module -Name PnP.PowerShell -Scope CurrentUser
Connect-PnPOnline -Url "https://quantr.sharepoint.com/gitlab" -Interactive
Remove-PnPList -Identity "Commit" -Recycle -Force -LargeList
Get-PnPLargeListOperationStatus -Identity "60f2e783-aba5-46e8-9621-070ede81482b" -OperationId "2a93bded-42f7-4879-977a-20d631216bc4"

chmod+x petalinux-v20XX.X-final-installer.run
./petalinux-v20XX.X-final-installer.run

source /opt/petalinux/settings.sh
petalinux-create --type project --template zynq --name petalinux_boot_from_flash
cd petalinux_boot_from_flash
find .. -name "*.xsa"
cp ../petalinux_boot_from_flash_vivado/design_1_wrapper.xsa .
petalinux-config --get-hw-description=.

petalinux-package --boot --fsbl images/linux/zynq_fsbl.elf --u-boot images/linux/u-boot.elf --force

~/xilinx/2026.1/Vitis/bin/program_flash -f images/linux/BOOT.BIN \
       -offset 0x0 \
       -fsbl images/linux/zynq_fsbl.elf \
       -flash_type qspi_single \
       -verify \
       -url tcp:localhost:3121

source .S  →  preprocessor  →  ANTLR parse + encode  →  bin / ELF

macro : define | ifdef | include | dotbyte | dothalf | dotword | dotdword | dotstring ;

src/main/java/hk/quantr/assembler/antlr/RISCVAssemblerLexer.g4
src/main/java/hk/quantr/assembler/antlr/RISCVAssemblerParser.g4
src/main/java/hk/quantr/assembler/AssemblerLib.java
src/main/java/hk/quantr/assembler/Assembler.java
src/main/java/hk/quantr/assembler/riscv/listener/DefineListener.java
src/main/java/hk/quantr/assembler/riscv/listener/IncludeListener.java
src/main/java/hk/quantr/assembler/riscv/RISCVEncoder.java
src/main/java/hk/quantr/assembler/riscv/preprocess/   (new)
src/test/java/hk/quantr/assembler/riscv/TestGasMacro.java  (new)

DOTMACRO    :   '.macro';
DOTENDM     :   '.endm';
DOTEXITM    :   '.exitm';

	.macro	E
	la	a3, 7b
	call	test_end
	.endm

	.macro	LDD freg, sym
	la	a0, \sym
	c.fld	\freg, 0(a0)
	.endm

String src = Files.readString(Path.of("src/test/resources/macro_ldd.s"));
String expanded = Preprocessor.expand(src, "rv64");
byte[] ours = assembleRv64(expanded);
byte[] gas = gasAssemble(src);   // riscv64-elf-as -march=rv64imafdc
assertArrayEquals(gas, ours);

.if  expr
.ifdef name
.ifndef name
.else
.endif
.rept N
.endr

LINE_COMMENT : [;#] ~[\r\n]* ;

section : DOT sectionName=IDENTIFIER IDENTIFIER? ;

.text
.data
.rodata
.bss
.align  N
.globl  name
.asciz  "string"
.ascii  "string"
.pushsection name
.popsection

.option rvc
.option norvc
.option push
.option pop

# gas
riscv64-elf-as -march=rv64imafdc -o gas.o t.s
riscv64-elf-objcopy -O binary --only-section=.text gas.o gas.bin

# ours, after you wire preProcess into main
java -jar target/assembler-*-jar-with-dependencies.jar -a rv64 -f bin -o ours.bin t.s

cmp gas.bin ours.bin

export GDK_SCALE=2 GDK_DPI_SCALE=0.5
export _JAVA_OPTIONS="-Dsun.java2d.uiScale=2.5"

chmod +x petalinux-v20XX.X-final-installer.run
./petalinux-v20XX.X-final-installer.run

git clone https://github.com/karolzmijewski/z7-nano-7020.git
mkdir /home/peter/xilinx/2026.1/data/boards/board_files
cp -r z7-nano-7020/board_files/z7-nano-7020 /home/peter/xilinx/2026.1/data/boards/board_files/

source home/peter/xilinx/2026.1/Model_Composer/settings64.sh
source /opt/petalinux/settings.sh
petalinux-create -t project --template zynq -n z7nano-linux
cd z7nano-linux
petalinux-config --get-hw-description=/path/to/xsa/dir

petalinux-config -c kernel
petalinux-config -c rootfs 

petalinux-build

petalinux-package --boot --fsbl images/linux/zynq_fsbl.elf \
                   --fpga images/linux/system.bit \
                   --u-boot --force

petalinux-package --boot --fsbl images/linux/zynq_fsbl.elf --u-boot images/linux/u-boot.elf --force

sudo mkfs.vfat -F 32 -n BOOT /dev/sdX1
sudo mkfs.ext4 -L rootfs /dev/sdX2
sudo mount /dev/sdX1 /mnt/boot
sudo cp images/linux/BOOT.BIN images/linux/image.ub /mnt/boot/
sudo umount /mnt/boot
sudo mount /dev/sdX2 /mnt/root
sudo tar xzf images/linux/rootfs.tar.gz -C /mnt/root
sudo umount /mnt/root

git lfs install

    "http.proxy": "http://3.1.240.71:8888",
    "http.proxySupport": "override",
    "http.noProxy": [
        "localhost",
        "127.0.0.1",
        "192.168.1.88",
        "192.168.1.88:1234",
        "61.244.87.154",
        "github.com",
        "gitlab.quantr.hk",
        "gitlab.hkprog.org"
    ],
    "chat.sessionSync.enabled": true,
    "cursor.general.disableHttp2": true

git clone [email protected]:qemu/qemu.git

export PATH="$(brew --prefix bison)/bin:$PATH"
export PKG_CONFIG_PATH="$(brew --prefix glib)/lib/pkgconfig:$PKG_CONFIG_PATH"

# ./configure --extra-cflags="-I/opt/homebrew/opt/libiconv/include -I/usr/local/include" --extra-ldflags="-L/opt/homebrew/opt/libiconv/lib -L/usr/local/lib" --target-list=riscv64-softmmu --enable-plugins

./configure --extra-cflags="-I$(brew --prefix libiconv)/include -I/usr/local/include" --extra-ldflags="-L$(brew --prefix libiconv)/lib -L/usr/local/lib" --target-list=riscv64-softmmu --enable-plugins

make -j
sudo make install

brew install riscv64-elf-gcc riscv64-elf-binutils riscv64-elf-gdb
git clone [email protected]:mit-pdos/xv6-riscv.git
make -j
make qemu

ssh-keygen -t ed25519 -C "[email protected]" -f ~/.ssh/github
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/github
cat ~/.ssh/github.pub

https://github.com/settings/keys

vi ~/.ssh/config

Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/github
  AddKeysToAgent yes

//PA10 (RX) and PA9 (TX)

void setup() {
  // Initialize USB CDC
  Serial.begin(9600); 
  
  // Initialize Hardware UART
  Serial1.begin(9600); 
}

void loop() {
  // Read from USB and send to UART
  if (Serial.available()) {
    Serial1.write(Serial.read());
  }
  
  // Read from UART and send to USB
  if (Serial1.available()) {
    Serial.write(Serial1.read());
  }
}

#define F_CPU 16000000UL  // 1. Define CPU Frequency (16MHz is common for 328PB)
#include <avr/io.h>
#include <util/delay.h>   // 2. Include the delay library

int main(void) {
    // 3. Set PD7 as an output
    // DDRD is the Data Direction Register for Port D
    DDRD |= (1 << DDD7); 

    while (1) {
        // 4. Toggle PD7 using the XOR operator
        PORTD ^= (1 << PORTD7);
        
        // 5. Wait for 500 milliseconds
        _delay_ms(500);
    }
}

export PATH="/Applications/microchip/mplabx/v6.30/mplab_platform/mplab_ipe/:$PATH"

MODEL=atmega328p
MODEL_AVRDUDE=m328pb
# MODEL_ISP=usbasp-clone
MODEL_ISP=avrisp2 # mkII

# For Microchip IPECMD, the device name usually needs to match the exact chip
MODEL_IPE=ATmega328PB
# IPECMD Tool Configuration
# -TPPK5 tells IPE to use the PICkit 5
TOOL_IPE=-TPPK5

all: SSD1306.o TWI.o main.hex

SSD1306.o: ssd1306/SSD1306.c
	avr-gcc -mmcu=$(MODEL)  -Wall -Os -c $? -o $@

TWI.o: ssd1306/TWI.c
	avr-gcc -mmcu=$(MODEL)  -Wall -Os -c $? -o $@

main.hex: main.c
	avr-gcc -mmcu=$(MODEL)  -Wall -Os -o main.elf SSD1306.o TWI.o main.c
	avr-objcopy -j .text -j .data -O ihex main.elf main.hex
	avr-size --format=avr --mcu=$(MODEL) main.elf

upload:
	avrdude -c $(MODEL_ISP) -p $(MODEL_AVRDUDE) -U flash:w:main.hex

upload_pickit5:
	ipecmd.sh $(TOOL_IPE) -P$(MODEL_IPE) -F"$(CURDIR)/main.hex" -M

readfuse:
	avrdude -c $(MODEL_ISP) -p $(MODEL_AVRDUDE) -U hfuse:r:-:h -U lfuse:r:-:h

writefuse:
	avrdude -c $(MODEL_ISP) -p $(MODEL_AVRDUDE) -U lfuse:w:0x62:m -U hfuse:w:0xD9:m -U efuse:w:0xFF:m -U lock:w:0xFF:m

clean:
	-rm *.o
	-rm main.hex
	-rm main.elf

GAL22V10
AND_Gate

Clock A  B  NC NC NC NC NC NC NC NC GND
NC    NC NC NC NC NC NC NC NC NC Y  VCC


Y = A * B			; AND gate: Y is high only when both A and B are high


DESCRIPTION
Simple 2-input AND gate example using a GAL22V10.
Inputs:  A (pin 2), B (pin 3)
Output:  Y (pin 23) - combinatorial output

galasm and.pld
minipro -p ATF22V10C -w and.jed

minipro -p ATF22V10C -r output.jed

import re
import sys

def expand_jedec_32bits(input_text):
    # 1. Determine default value from *F flag
    default_val = '0' if '*F0' in input_text else '1'
    
    qf_match = re.search(r'\*QF(\d+)', input_text)
    if not qf_match:
        raise ValueError("Could not find fuse count (*QF) field in JEDEC file.")
    total_fuses = int(qf_match.group(1))
    
    # 2. Initialize the entire fuse array with the default value
    fuse_array = [default_val] * total_fuses
    
    # 3. Parse and fill explicit allocation fields (*LXXXX)
    l_fields = re.findall(r'\*L(\d+)\s+([01\s]+)', input_text)
    
    for start_index_str, bit_string in l_fields:
        start_index = int(start_index_str)
        bits = bit_string.replace(" ", "").replace("\n", "").replace("\r", "")
        
        for i, bit in enumerate(bits):
            if start_index + i < total_fuses:
                fuse_array[start_index + i] = bit

    # 4. Calculate Fuse Checksum (Sum of all 8-bit fuse bytes)
    fuse_checksum = 0
    for i in range(0, total_fuses, 8):
        byte_bits = "".join(fuse_array[i:i+8])
        if len(byte_bits) < 8:
            byte_bits = byte_bits.ljust(8, '0')
        # Standard JEDEC checksum mirrors the bit order of each byte
        byte_val = int(byte_bits[::-1], 2)
        fuse_checksum = (fuse_checksum + byte_val) & 0xFFFF

    # 5. Construct the Longform Output Body (Row width = 32 bits)
    output_lines = []
    
    # Grab everything before the QF tag to keep original headers/comments
    header_end_idx = input_text.find('*QF')
    output_lines.append(input_text[:header_end_idx].strip())
    output_lines.append(f"*QF{total_fuses}*")
    
    row_size = 32  # 32 bits per row configuration
    for addr in range(0, total_fuses, row_size):
        chunk = fuse_array[addr:addr+row_size]
        chunk_str = "".join(chunk)
        
        # Append row format: *L<address> <bits>*
        # Keeping a space here as it is standard formatting for readability
        output_lines.append(f"*L{addr:05d} {chunk_str}")

    # Add the generated fuse checksum
    output_lines.append(f"*C{fuse_checksum:04X}*")
    
    # End of text transmission block
    output_body = "\n".join(output_lines) + "\n\x03"
    
    # 6. Calculate File Checksum (ASCII sum from STX to ETX)
    file_checksum = sum(ord(c) for c in output_body) + 0x02  # Include STX (0x02)
    file_checksum &= 0xFFFF
    
    final_jedec = f"\x02\n{output_body}{file_checksum:04x}"
    return final_jedec

# --- Execution ---
if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: expand_jedec.py <input.jed> [output.jed]")
        sys.exit(1)

    input_file = sys.argv[1]
    output_file = sys.argv[2] if len(sys.argv) > 2 else input_file.rsplit(".", 1)[0] + "_expanded.jed"

    try:
        with open(input_file, "r", encoding="ascii") as f:
            shortform_data = f.read()

        longform_jedec = expand_jedec_32bits(shortform_data)
        with open(output_file, "w", encoding="ascii") as f:
            f.write(longform_jedec)
        print(f"Success! Generated '{output_file}' with 32-bit width arrays.")
    except FileNotFoundError:
        print(f"Error: Input file '{input_file}' not found.")
        sys.exit(1)
    except Exception as e:
        print(f"Error expanding JEDEC map: {e}")
        sys.exit(1)

    "telemetry.enableTelemetry": false,
    "telemetry.telemetryLevel": "off"

cd /opt/homebrew/lib/pkgconfig   # or /usr/local/lib/pkgconfig if on Intel Mac
ln -s glibmm-2.68.pc glibmm-2.4.pc

cd /Users/peter/workspace/pulseview
rm -rf CMakeCache.txt CMakeFiles/
make clean   # or just rm -rf the build artefacts if needed
export PKG_CONFIG_PATH="/usr/local/opt/glib/lib/pkgconfig:/usr/local/opt/qt@6/lib/pkgconfig:$PKG_CONFIG_PATH"
cmake .
make -j

mpremote exec "import flashRead_w25; flashRead_w25.dump_flash(0, 1280)"
mpremote exec "import flashWrite_w25; flashWrite_w25.write('w 2 0x23 3 0x45')"

import machine
import time
import ssd1306
from machine import SPI, Pin

# W25Q128 SPI Flash Configuration
# W25Q128 has 16MB (16777216 bytes) = 128 Mbit
# Page size: 256 bytes
# Sector size: 4KB
# Block size: 64KB

# W25Q128 Commands
CMD_WRITE_ENABLE = 0x06
CMD_WRITE_DISABLE = 0x04
CMD_READ_STATUS = 0x05
CMD_READ_STATUS2 = 0x35
CMD_READ_STATUS3 = 0x15
CMD_WRITE_STATUS = 0x01
CMD_READ_DATA = 0x03
CMD_PAGE_PROGRAM = 0x02
CMD_SECTOR_ERASE = 0x20
CMD_BLOCK_ERASE_32K = 0x52
CMD_BLOCK_ERASE_64K = 0xD8
CMD_CHIP_ERASE = 0xC7
CMD_READ_ID = 0x9F
CMD_POWER_DOWN = 0xB9
CMD_RELEASE_POWER_DOWN = 0xAB
CMD_RESET_ENABLE = 0x66
CMD_RESET_MEMORY = 0x99

# SPI Configuration
spi = None
cs = None

def init_spi():
    global spi, cs
    # Initialize SPI bus (SPI1) for WeAct BlackPill
    # SCK=PA5, MISO=PA6, MOSI=PA7
    try:
        spi = machine.SPI(
            1,
            baudrate=1000000,
            polarity=0,
            phase=0,
            bits=8,
            firstbit=machine.SPI.MSB,
            sck=machine.Pin('A5'),
            mosi=machine.Pin('A7'),
            miso=machine.Pin('A6'),
        )
    except (ValueError, TypeError):
        try:
            spi = machine.SPI(1, baudrate=1000000, polarity=0, phase=0)
        except Exception:
            spi = machine.SoftSPI(
                baudrate=500000,
                polarity=0,
                phase=0,
                sck=machine.Pin('A5'),
                mosi=machine.Pin('A7'),
                miso=machine.Pin('A6'),
            )

    # CS pin (adjust based on your wiring)
    cs = machine.Pin('A4', machine.Pin.OUT, value=1)
    time.sleep_ms(1)

    flash_wake()
    flash_reset()

    disable_protection()
    
    # Check device ID
    device_id = read_device_id()
    if device_id == 0x000000:
        time.sleep_ms(5)
        device_id = read_device_id()
    print(f"W25Q128 Device ID: {device_id:06X}")
    if device_id == 0xEF4018:
        print("W25Q128 detected successfully")
    else:
        print(f"Warning: Unexpected device ID: {device_id:06X} (expected 0xEF4018)")

def read_device_id():
    """Read W25Q128 manufacturer and device ID"""
    cs.value(0)
    spi.write(bytes([CMD_READ_ID]))
    id_data = spi.read(3)
    cs.value(1)
    return (id_data[0] << 16) | (id_data[1] << 8) | id_data[2]

def flash_wake():
    """Release from power-down (safe to call even if not asleep)"""
    cs.value(0)
    spi.write(bytes([CMD_RELEASE_POWER_DOWN]))
    cs.value(1)
    time.sleep_ms(1)

def flash_reset():
    """Reset the flash (W25Q series supports 0x66/0x99)"""
    cs.value(0)
    spi.write(bytes([CMD_RESET_ENABLE]))
    cs.value(1)
    time.sleep_us(50)
    cs.value(0)
    spi.write(bytes([CMD_RESET_MEMORY]))
    cs.value(1)
    time.sleep_ms(1)

def read_status():
    """Read status register"""
    cs.value(0)
    spi.write(bytes([CMD_READ_STATUS]))
    status = spi.read(1)[0]
    cs.value(1)
    return status

def read_status2():
    """Read status register-2"""
    cs.value(0)
    spi.write(bytes([CMD_READ_STATUS2]))
    status = spi.read(1)[0]
    cs.value(1)
    return status

def read_status3():
    """Read status register-3"""
    cs.value(0)
    spi.write(bytes([CMD_READ_STATUS3]))
    status = spi.read(1)[0]
    cs.value(1)
    return status

def write_status(sr1, sr2):
    """Write status register-1 and -2"""
    wait_busy()
    write_enable()
    cs.value(0)
    spi.write(bytes([CMD_WRITE_STATUS, sr1 & 0xFF, sr2 & 0xFF]))
    cs.value(1)
    wait_busy()

def disable_protection():
    """Clear block protection bits and SRP"""
    sr1 = read_status()
    sr2 = read_status2()
    sr3 = read_status3()
    if (sr1 & 0x1C) or (sr1 & 0x80):
        print(f"Status before: SR1={sr1:02X} SR2={sr2:02X} SR3={sr3:02X}")
        write_status(sr1 & ~0x9C, sr2 & ~0x40)
        sr1 = read_status()
        sr2 = read_status2()
        sr3 = read_status3()
        print(f"Status after:  SR1={sr1:02X} SR2={sr2:02X} SR3={sr3:02X}")

def wait_busy():
    """Wait until write operation completes"""
    while read_status() & 0x01:
        time.sleep_us(10)

def write_enable():
    """Enable write operations"""
    cs.value(0)
    spi.write(bytes([CMD_WRITE_ENABLE]))
    cs.value(1)

def write_disable():
    """Disable write operations"""
    cs.value(0)
    spi.write(bytes([CMD_WRITE_DISABLE]))
    cs.value(1)

def read_byte(addr):
    """Read a single byte from address"""
    cs.value(0)
    spi.write(bytes([CMD_READ_DATA, (addr >> 16) & 0xFF, (addr >> 8) & 0xFF, addr & 0xFF]))
    data = spi.read(1)[0]
    cs.value(1)
    return data

def read_bytes(addr, length):
    """Read multiple bytes from address"""
    cs.value(0)
    spi.write(bytes([CMD_READ_DATA, (addr >> 16) & 0xFF, (addr >> 8) & 0xFF, addr & 0xFF]))
    data = spi.read(length)
    cs.value(1)
    return data

def write_page(addr, data):
    """Write up to 256 bytes (one page). Address must be page-aligned."""
    if len(data) > 256:
        raise ValueError("Page write data must be <= 256 bytes")
    
    wait_busy()
    write_enable()

    # Ensure write-enable latch is set (bit 1)
    if (read_status() & 0x02) == 0:
        write_enable()
        if (read_status() & 0x02) == 0:
            raise RuntimeError("Write enable latch not set. Check /WP pin.")
    
    cs.value(0)
    spi.write(bytes([CMD_PAGE_PROGRAM, (addr >> 16) & 0xFF, (addr >> 8) & 0xFF, addr & 0xFF]))
    spi.write(data)
    cs.value(1)
    
    wait_busy()

def write_byte(addr, value):
    """Write a single byte to address"""
    write_page(addr, bytes([value & 0xFF]))

def sector_erase(addr):
    """Erase a 4KB sector (sector address must be sector-aligned)"""
    wait_busy()
    write_enable()

    if (read_status() & 0x02) == 0:
        write_enable()
        if (read_status() & 0x02) == 0:
            raise RuntimeError("Write enable latch not set. Check /WP pin.")
    
    cs.value(0)
    spi.write(bytes([CMD_SECTOR_ERASE, (addr >> 16) & 0xFF, (addr >> 8) & 0xFF, addr & 0xFF]))
    cs.value(1)
    
    wait_busy()

def block_erase_64k(addr):
    """Erase a 64KB block (address must be block-aligned)"""
    wait_busy()
    write_enable()
    
    cs.value(0)
    spi.write(bytes([CMD_BLOCK_ERASE_64K, (addr >> 16) & 0xFF, (addr >> 8) & 0xFF, addr & 0xFF]))
    cs.value(1)
    
    wait_busy()

def chip_erase():
    """Erase entire chip (takes several seconds)"""
    wait_busy()
    write_enable()
    
    cs.value(0)
    spi.write(bytes([CMD_CHIP_ERASE]))
    cs.value(1)
    
    print("Chip erase started (this may take 10-30 seconds)...")
    wait_busy()
    print("Chip erase complete")

def write_00_to_ff():
    init_spi()
    
    # i2c_display = machine.I2C(1)
    # display = ssd1306.SSD1306_I2C(128, 64, i2c_display)
    # display.fill(0)
    # display.text("W25Q128 Writer", 5, 5, 1)
    # display.show()

    # Erase first 64KB (16 sectors) before writing
    # for sector in range(0, 16):
    #     sector_addr = sector * 0x1000
    #     print(f"E {sector_addr:06X}")
    #     sector_erase(sector_addr)

    # Write first 64KB for testing, page-by-page
    for page_addr in range(0, 65536, 256):
        if page_addr % 1000 == 0:
            print(f"W {page_addr:06X}")
            # display.fill(0)
            # display.text("W25Q128 Writer", 5, 5, 1)
            # display.text(f"W {page_addr:06X}", 5, 30, 1)
            # display.show()

        page = bytes([(page_addr + i) & 0xFF for i in range(256)])
        write_page(page_addr, page)

    # display.fill(0)
    # display.text("W25Q128 Writer", 5, 5, 1)
    # display.text(f"Write Complete", 5, 30, 1)
    # display.show()


def write(str):
    init_spi()
    
    # Parse the input string into address-value pairs and write each value
    str = str[2:]  # Remove "w " prefix
    tokens = str.strip().split()
    if len(tokens) % 2 != 0:
        raise ValueError("Input string must contain pairs of <addr> <value>")
    
    # i2c_display = machine.I2C(1)
    # display = ssd1306.SSD1306_I2C(128, 64, i2c_display)
    # display.fill(0)
    # display.text("W25Q128 Writer", 5, 5, 1)
    # display.show()

    for i in range(0, len(tokens), 2):
        addr = int(tokens[i], 0)  # Support hex (0x...), decimal, etc.
        value = int(tokens[i+1], 0)
        write_byte(addr, value)

        if addr > 0 and addr % 1000 == 0:
            print(f"Wrote {value:02X} to {addr:06X}")
            # display.fill(0)
            # display.text("W25Q128 Writer", 5, 5, 1)
            # display.text(f"W {value:02X} to {addr:06X}", 5, 30, 1)
            # display.show()

    # display.fill(0)
    # display.text("W25Q128 Writer", 5, 5, 1)
    # display.text(f"W {value:02X} to {addr:06X}", 5, 30, 1)
    # display.show()


def erase():
    init_spi()
    
    print("Erasing entire W25Q128 chip...")
    chip_erase()
    print("Erase complete")


def erase_sector(sector_addr):
    """Erase a specific 4KB sector"""
    init_spi()
    
    # Align to sector boundary (4KB = 0x1000)
    sector_addr = sector_addr & 0xFFFFF000
    print(f"Erasing sector at {sector_addr:06X}...")
    sector_erase(sector_addr)
    print(f"Sector at {sector_addr:06X} erased")


if __name__ == "__main__":
    write_00_to_ff()

import machine
import time
import ssd1306
from machine import SPI, Pin

# W25Q128 SPI Flash Configuration
# W25Q128 has 16MB (16777216 bytes) = 128 Mbit

# W25Q128 Commands
CMD_READ_DATA = 0x03
CMD_READ_STATUS = 0x05
CMD_READ_ID = 0x9F
CMD_FAST_READ = 0x0B
CMD_POWER_DOWN = 0xB9
CMD_RELEASE_POWER_DOWN = 0xAB
CMD_RESET_ENABLE = 0x66
CMD_RESET_MEMORY = 0x99

# SPI Configuration
spi = None
cs = None

def init_spi():
    global spi, cs
    # Initialize SPI bus (SPI1) for WeAct BlackPill
    # SCK=PA5, MISO=PA6, MOSI=PA7
    try:
        spi = machine.SPI(
            1,
            baudrate=1000000,
            polarity=0,
            phase=0,
            bits=8,
            firstbit=machine.SPI.MSB,
            sck=machine.Pin('A5'),
            mosi=machine.Pin('A7'),
            miso=machine.Pin('A6'),
        )
    except (ValueError, TypeError):
        try:
            spi = machine.SPI(1, baudrate=1000000, polarity=0, phase=0)
        except Exception:
            spi = machine.SoftSPI(
                baudrate=500000,
                polarity=0,
                phase=0,
                sck=machine.Pin('A5'),
                mosi=machine.Pin('A7'),
                miso=machine.Pin('A6'),
            )

    # CS pin (adjust based on your wiring)
    cs = machine.Pin('A4', machine.Pin.OUT, value=1)
    time.sleep_ms(1)

    flash_wake()
    flash_reset()
    
    # Check device ID
    device_id = read_device_id()
    if device_id == 0x000000:
        time.sleep_ms(5)
        device_id = read_device_id()
    print(f"W25Q128 Device ID: {device_id:06X}")
    if device_id == 0xEF4018:
        print("W25Q128 detected successfully")
    else:
        print(f"Warning: Unexpected device ID: {device_id:06X} (expected 0xEF4018)")

def read_device_id():
    """Read W25Q128 manufacturer and device ID"""
    cs.value(0)
    spi.write(bytes([CMD_READ_ID]))
    id_data = spi.read(3)
    cs.value(1)
    return (id_data[0] << 16) | (id_data[1] << 8) | id_data[2]

def flash_wake():
    """Release from power-down (safe to call even if not asleep)"""
    cs.value(0)
    spi.write(bytes([CMD_RELEASE_POWER_DOWN]))
    cs.value(1)
    time.sleep_ms(1)

def flash_reset():
    """Reset the flash (W25Q series supports 0x66/0x99)"""
    cs.value(0)
    spi.write(bytes([CMD_RESET_ENABLE]))
    cs.value(1)
    time.sleep_us(50)
    cs.value(0)
    spi.write(bytes([CMD_RESET_MEMORY]))
    cs.value(1)
    time.sleep_ms(1)

def read_status():
    """Read status register"""
    cs.value(0)
    spi.write(bytes([CMD_READ_STATUS]))
    status = spi.read(1)[0]
    cs.value(1)
    return status

def read_byte(addr):
    """Read a single byte from address"""
    cs.value(0)
    spi.write(bytes([CMD_READ_DATA, (addr >> 16) & 0xFF, (addr >> 8) & 0xFF, addr & 0xFF]))
    data = spi.read(1)[0]
    cs.value(1)
    return data

def read_bytes(addr, length):
    """Read multiple bytes from address"""
    cs.value(0)
    spi.write(bytes([CMD_READ_DATA, (addr >> 16) & 0xFF, (addr >> 8) & 0xFF, addr & 0xFF]))
    data = spi.read(length)
    cs.value(1)
    return data

def dump_flash(start, length):
    """Dump W25Q128 flash contents"""
    init_spi()
    
    # Initialize display (optional)
    # i2c_display = machine.I2C(1)
    # display = ssd1306.SSD1306_I2C(128, 64, i2c_display)
    # display.fill(0)
    # display.text("W25Q128 Reader", 5, 5, 1)
    # display.show()
    
    for base in range(start, start + length, 16):
        row = [f"{base:06X}:"]

        # if base % 1000 == 0:
        #     display.fill(0)
        #     display.text("W25Q128 Reader", 5, 5, 1)
        #     display.text(f"R {base:06X}", 5, 30, 1)
        #     display.show()

        chunk_len = min(16, (start + length) - base)
        data = read_bytes(base, chunk_len)
        for b in data:
            row.append(f"{b:02X}")
        print(' '.join(row))

if __name__ == "__main__":
    # W25Q128 has 16MB (16777216 bytes)
    # Read first 64KB for testing
    dump_flash(0, 65536)

"""
MPU9250 MicroPython Example
9-axis IMU (Accelerometer, Gyroscope, Magnetometer)
"""

from machine import I2C, Pin
from time import sleep_ms, ticks_ms, ticks_diff
import math

class MPU9250:
    """MPU9250 9-axis IMU driver"""
    
    # MPU9250 I2C address
    MPU9250_ADDRESS = 0x68
    AK8963_ADDRESS = 0x0C
    
    # Register addresses
    PWR_MGMT_1 = 0x6B
    ACCEL_XOUT_H = 0x3B
    GYRO_XOUT_H = 0x43
    TEMP_OUT_H = 0x41
    WHO_AM_I = 0x75
    
    # Magnetometer registers
    MAG_CNTL = 0x0A
    MAG_XOUT_L = 0x03
    MAG_ST1 = 0x02
    MAG_CNTL2 = 0x0B
    MAG_ASAX = 0x10
    
    # Configuration registers
    CONFIG = 0x1A
    GYRO_CONFIG = 0x1B
    ACCEL_CONFIG = 0x1C
    ACCEL_CONFIG2 = 0x1D
    INT_PIN_CFG = 0x37
    USER_CTRL = 0x6A
    
    def __init__(self, i2c, address=MPU9250_ADDRESS):
        self.i2c = i2c
        self.address = address
        
        # Wake up the MPU9250
        self.i2c.writeto_mem(self.address, self.PWR_MGMT_1, b'\x00')
        sleep_ms(100)
        
        # Check WHO_AM_I register
        who_am_i = self.i2c.readfrom_mem(self.address, self.WHO_AM_I, 1)[0]
        if who_am_i != 0x71:
            raise RuntimeError(f"MPU9250 not found. WHO_AM_I: 0x{who_am_i:02X}")
        
        # Configure gyroscope (±250°/s)
        self.i2c.writeto_mem(self.address, self.GYRO_CONFIG, b'\x00')
        
        # Configure accelerometer (±2g)
        self.i2c.writeto_mem(self.address, self.ACCEL_CONFIG, b'\x00')
        
        # Set accelerometer data rate (1kHz) and bandwidth (184Hz)
        self.i2c.writeto_mem(self.address, self.ACCEL_CONFIG2, b'\x01')
        
        # Set gyroscope data rate (1kHz) and bandwidth (184Hz)
        self.i2c.writeto_mem(self.address, self.CONFIG, b'\x01')
        
        # Initialize magnetometer
        self._init_magnetometer()
        
        print("MPU9250 initialized successfully")
    
    def read_accel(self):
        """Read accelerometer data (m/s²)"""
        data = self.i2c.readfrom_mem(self.address, self.ACCEL_XOUT_H, 6)
        
        # Convert to signed 16-bit integers
        ax = self._combine_bytes(data[0], data[1])
        ay = self._combine_bytes(data[2], data[3])
        az = self._combine_bytes(data[4], data[5])
        
        # Scale to g (±2g range, 16384 LSB/g)
        scale = 16384.0
        ax = (ax / scale) * 9.81  # Convert to m/s²
        ay = (ay / scale) * 9.81
        az = (az / scale) * 9.81
        
        return (ax, ay, az)
    
    def read_gyro(self):
        """Read gyroscope data (°/s)"""
        data = self.i2c.readfrom_mem(self.address, self.GYRO_XOUT_H, 6)
        
        # Convert to signed 16-bit integers
        gx = self._combine_bytes(data[0], data[1])
        gy = self._combine_bytes(data[2], data[3])
        gz = self._combine_bytes(data[4], data[5])
        
        # Scale to °/s (±250°/s range, 131 LSB/°/s)
        scale = 131.0
        gx = gx / scale
        gy = gy / scale
        gz = gz / scale
        
        return (gx, gy, gz)
    
    def read_temp(self):
        """Read temperature (°C)"""
        data = self.i2c.readfrom_mem(self.address, self.TEMP_OUT_H, 2)
        temp_raw = self._combine_bytes(data[0], data[1])
        
        # Convert to °C
        temp = (temp_raw / 333.87) + 21.0
        return temp
    
    def _init_magnetometer(self):
        """Initialize AK8963 magnetometer"""
        # Enable I2C master mode and set I2C bypass
        self.i2c.writeto_mem(self.address, self.INT_PIN_CFG, b'\x02')
        sleep_ms(10)
        
        # Power down magnetometer
        self.i2c.writeto_mem(self.AK8963_ADDRESS, self.MAG_CNTL, b'\x00')
        sleep_ms(10)
        
        # Enter fuse ROM access mode
        self.i2c.writeto_mem(self.AK8963_ADDRESS, self.MAG_CNTL, b'\x0F')
        sleep_ms(10)
        
        # Read sensitivity adjustment values
        asa_data = self.i2c.readfrom_mem(self.AK8963_ADDRESS, self.MAG_ASAX, 3)
        self.mag_sensitivity = [(((d - 128) * 0.5) / 128 + 1) for d in asa_data]
        
        # Power down magnetometer
        self.i2c.writeto_mem(self.AK8963_ADDRESS, self.MAG_CNTL, b'\x00')
        sleep_ms(10)
        
        # Set to continuous measurement mode (16-bit, 100Hz)
        self.i2c.writeto_mem(self.AK8963_ADDRESS, self.MAG_CNTL, b'\x16')
        sleep_ms(10)
        
        print("Magnetometer initialized")
    
    def read_mag(self):
        """Read magnetometer data (µT - microtesla)"""
        try:
            # Check if data is ready
            status = self.i2c.readfrom_mem(self.AK8963_ADDRESS, self.MAG_ST1, 1)[0]
            if not (status & 0x01):
                return (0, 0, 0)
            
            # Read magnetometer data (7 bytes: ST1, XL, XH, YL, YH, ZL, ZH)
            data = self.i2c.readfrom_mem(self.AK8963_ADDRESS, self.MAG_XOUT_L, 7)
            
            # Check overflow
            if data[6] & 0x08:
                return (0, 0, 0)
            
            # Convert to signed 16-bit integers (little-endian)
            mx = self._combine_bytes(data[2], data[1])
            my = self._combine_bytes(data[4], data[3])
            mz = self._combine_bytes(data[6], data[5])
            
            # Apply sensitivity adjustment
            mx = mx * self.mag_sensitivity[0] * 0.6  # Convert to µT (4912/32760 * 4)
            my = my * self.mag_sensitivity[1] * 0.6
            mz = mz * self.mag_sensitivity[2] * 0.6
            
            return (mx, my, mz)
        except:
            return (0, 0, 0)
    
    def _combine_bytes(self, msb, lsb):
        """Combine two bytes into signed 16-bit integer"""
        value = (msb << 8) | lsb
        if value >= 0x8000:
            value = -((65535 - value) + 1)
        return value


def main():
    """Example usage of MPU9250"""
    
    # Initialize I2C
    # For ESP32-C6: Adjust pins according to your wiring
    i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)
    
    # Scan I2C bus
    print("Scanning I2C bus...")
    devices = i2c.scan()
    print(f"Found devices: {[hex(d) for d in devices]}")
    
    # Initialize MPU9250
    try:
        mpu = MPU9250(i2c)
    except Exception as e:
        print(f"Error initializing MPU9250: {e}")
        return
    
    print("\nReading MPU9250 data...")
    print("Press Ctrl+C to stop\n")
    
    # Initialize angle tracking
    angle_x = 0.0
    angle_y = 0.0
    angle_z = 0.0
    last_time = ticks_ms()
    
    try:
        while True:
            # Calculate time difference
            current_time = ticks_ms()
            dt = ticks_diff(current_time, last_time) / 1000.0  # Convert to seconds
            last_time = current_time
            
            # Read accelerometer
            ax, ay, az = mpu.read_accel()
            
            # Read gyroscope
            gx, gy, gz = mpu.read_gyro()
            
            # Integrate gyroscope to get angles
            angle_x += gx * dt
            angle_y += gy * dt
            angle_z += gz * dt
            
            # Read magnetometer
            mx, my, mz = mpu.read_mag()
            
            # Calculate heading (0-360°)
            heading = math.atan2(my, mx) * 180 / math.pi
            if heading < 0:
                heading += 360
            
            # Read temperature
            temp = mpu.read_temp()
            
            # clear console
            print("\033[2J\033[H", end="")  # ANSI escape codes to clear screen
            
            # Display data
            print("=" * 50)
            print(f"Accelerometer (m/s²):")
            print(f"  X: {ax:7.3f}  Y: {ay:7.3f}  Z: {az:7.3f}")
            print(f"Gyroscope Angles (°):")
            print(f"  Roll:  {angle_x:7.2f}°  (X-axis)")
            print(f"  Pitch: {angle_y:7.2f}°  (Y-axis)")
            print(f"  Yaw:   {angle_z:7.2f}°  (Z-axis)")
            print(f"Gyroscope Speed (°/s):")
            print(f"  X: {gx:7.2f}  Y: {gy:7.2f}  Z: {gz:7.2f}")
            print(f"Magnetometer (µT):")
            print(f"  X: {mx:7.2f}  Y: {my:7.2f}  Z: {mz:7.2f}")
            print(f"Heading: {heading:6.2f}° (0°=North, 90°=East)")
            print(f"Temperature: {temp:.2f}°C")
            
            sleep_ms(100)
            
    except KeyboardInterrupt:
        print("\n\nStopped by user")


if __name__ == "__main__":
    main()

# tb6612fng_simple.py
# MicroPython example for TB6612FNG + two DC motors (e.g. Tamiya 4WD)
# Works on Pico, ESP32, etc.

from machine import Pin, PWM
from time import sleep

# ────────────────────────────────────────────────
# Pin definitions (change to match YOUR wiring!)
# ────────────────────────────────────────────────

STBY = Pin(22, Pin.OUT)          # Standby pin – must be HIGH to enable driver

# Motor A (usually left motors on Tamiya 4WD)
AIN1 = Pin(18, Pin.OUT)
AIN2 = Pin(19, Pin.OUT)
PWMA = PWM(Pin(20), freq=1000, duty_u16=0)   # PWM freq 1kHz is fine

# ────────────────────────────────────────────────
# Helper functions
# ────────────────────────────────────────────────

def motor_a(speed):
    """
    speed: -1000 to +1000
      positive = forward
      negative = reverse
      0 = stop (coast)
    """
    if speed > 0:
        AIN1.value(1)
        AIN2.value(0)
        PWMA.duty_u16(speed * 65)          # 0→65535 range
    elif speed < 0:
        AIN1.value(0)
        AIN2.value(1)
        PWMA.duty_u16((-speed) * 65)
    else:
        AIN1.value(0)                       # coast stop
        AIN2.value(0)
        PWMA.duty_u16(0)


def drive(left_speed):
    """ left_speed: -1000 to 1000 """
    motor_a(left_speed)


# ────────────────────────────────────────────────
# Main demo
# ────────────────────────────────────────────────

STBY.value(1)  # Enable the driver (important!)
print("TB6612FNG enabled")

try:
    print("Forward slow...")
    drive(700)
    sleep(5)

    print("Forward full...")
    drive(1000)
    sleep(5)

    print("Stop (coast)...")
    drive(0)
    sleep(3)

    print("Backward slow...")
    drive(-700)
    sleep(5)

    print("Backward full...")
    drive(-1000)
    sleep(5)

    print("Brake demo (short brake)...")
    AIN1.value(1);
    AIN2.value(1)    # short brake on A
    PWMA.duty_u16(0)
    sleep(3)

    print("Stop everything")
    drive(0)

finally:
    STBY.value(0)               # Optional: go to low-power standby
    print("Done.")

#include <AccelStepper.h>

// STEP pin, DIR pin
AccelStepper stepper(AccelStepper::DRIVER, 4, 6);

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);

  stepper.moveTo(1);
  stepper.runToPosition();
  delay(500);
  
  digitalWrite(LED_BUILTIN, LOW);
  
  stepper.moveTo(-1);
  stepper.runToPosition();
  delay(500);
}

docker run -it -v .:/chisel-book --name ice40 ubuntu:24.04
apt-get update
export DEBIAN_FRONTEND=noninteractive
apt-get install build-essential clang bison flex libreadline-dev \
                     gawk tcl-dev libffi-dev git mercurial graphviz   \
                     xdot pkg-config python3 libftdi-dev vim \
                     curl openjdk-25-jdk python3-dev libboost-all-dev cmake libeigen3-dev -y
cd /chisel-book
mkdir ice40
cd ice40

git clone https://github.com/YosysHQ/icestorm.git icestorm
cd icestorm
make -j
make install
cd ..

git clone https://github.com/cseed/arachne-pnr.git arachne-pnr
cd arachne-pnr
make -j
make install
cd ..

git clone https://github.com/YosysHQ/nextpnr nextpnr
cd nextpnr
cmake -DARCH=ice40 -DCMAKE_INSTALL_PREFIX=/usr/local . -B build
cd build
make # -j won't work
make install
cd ../..

git clone https://github.com/YosysHQ/yosys.git yosys
cd yosys
git submodule update --init
make -j4
make install
cd ..

docker exec -it gitlab gitlab-backup create STRATEGY=copy

# 1. Stop GitLab
docker compose down

# 2. Put the .tar file into $GITLAB_HOME/data/backups/

# 3. Restore
docker exec -it gitlab gitlab-backup restore BACKUP=1732301234_2025_11_22_18.6.0

# 4. Start again
docker compose up -d

from machine import Pin
import time

class EC11:
    def __init__(self, pin_a, pin_b, pin_c):
        """
        Initialize EC11 rotary encoder for TaoBao version with external pull-ups
        pin_a, pin_b: rotation pins (Terminal A and B)
        pin_c: push button pin (Terminal C)
        
        IMPORTANT: This version has external 10K pull-ups to 5V
        So we use Pin.IN (no internal pull-up)
        """
        # No internal pull-ups since external 10K pull-ups exist
        self.pin_a = Pin(pin_a, Pin.IN)
        self.pin_b = Pin(pin_b, Pin.IN)
        # Use pull-down for button to make logic clearer: pressed=1, unpressed=0
        self.pin_c = Pin(pin_c, Pin.IN, Pin.PULL_DOWN)
        
        # Quadrature state tracking
        self.last_state = (self.pin_a.value() << 1) | self.pin_b.value()
        
        # Lookup table for quadrature decoding
        # Based on state transitions: 00->01->11->10->00 (CW) or reverse (CCW)
        self.state_table = [0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0]
        
        # Counter for rotation
        self.counter = 0
        
        # Accumulator for detent detection (4 steps = 1 detent)
        self.step_accumulator = 0
        
        # Button state tracking
        self.last_button = self.pin_c.value()
        self.button_debounce_time = 0
    
    def read_rotation(self):
        """
        Read rotation direction using quadrature decoding
        Returns: 1 for clockwise, -1 for counter-clockwise, 0 for no change
        """
        # Read current state
        current_state = (self.pin_a.value() << 1) | self.pin_b.value()
        
        # Calculate index for lookup table
        index = (self.last_state << 2) | current_state
        
        # Get direction from lookup table
        direction = self.state_table[index]
        
        # Accumulate steps - only return value after 4 steps (1 detent)
        if direction != 0:
            self.step_accumulator += direction
            self.counter += direction
            
            # Check if we've completed a detent (4 steps in one direction)
            if abs(self.step_accumulator) >= 4:
                result = 1 if self.step_accumulator > 0 else -1
                self.step_accumulator = 0
                self.last_state = current_state
                return result
        
        # Update last state
        self.last_state = current_state
        
        return 0
    
    def read_button(self):
        """
        Read button press with software debouncing
        Returns: True if button was just pressed, False otherwise
        """
        current_time = time.ticks_ms()
        current_button = self.pin_c.value()
        # print('current_button', current_button)
        
        # Button is pressed when pin goes HIGH (from LOW to HIGH)
        # With internal pull-down: unpressed=0, pressed=1
        # Add debouncing: ignore changes within 50ms
        if self.last_button == 0 and current_button == 1:
            if time.ticks_diff(current_time, self.button_debounce_time) > 50:
                self.button_debounce_time = current_time
                self.last_button = current_button
                return True
        
        self.last_button = current_button
        return False
    
    def get_counter(self):
        """Get current counter value"""
        return self.counter
    
    def reset_counter(self):
        """Reset counter to zero"""
        self.counter = 0

# Initialize EC11 with pins 3, 4, 5
encoder = EC11(pin_a=5, pin_b=3, pin_c=4)

print("EC11 Rotary Encoder Test (TaoBao Version)")
print("Pin A: 3, Pin B: 4, Pin C: 5")
print("External 10K pull-ups to 5V with 0.01uF caps")
print("Rotate encoder or press button...")
print("Press Ctrl+C to exit")
print()

try:
    while True:
        # Check rotation
        rotation = encoder.read_rotation()
        if rotation == 1:
            print(f"↻ Clockwise      - Counter: {encoder.get_counter()}")
        elif rotation == -1:
            print(f"↺ Anti-clockwise - Counter: {encoder.get_counter()}")
        
        # Check button press
        if encoder.read_button():
            print(f"🔘 Button pressed! Counter: {encoder.get_counter()} → 0")
            encoder.reset_counter()
        
        time.sleep_ms(1)  # Small delay to prevent excessive polling
        
except KeyboardInterrupt:
    print("\nProgram stopped")

# ws2812_3colors.py
from machine import Pin
from neopixel import NeoPixel
from time import sleep

# WS2812 LED on GPIO 8, 1 pixel
pin = Pin(8, Pin.OUT)
np = NeoPixel(pin, 1)

# Color values in GRB order: (Green, Red, Blue)
RED    = (0, 50, 0)   # Full red
GREEN  = (50, 0, 0)   # Full green
BLUE   = (0, 0, 50)   # Full blue
OFF    = (0, 0, 0)    # LED off

colors = [RED, GREEN, BLUE]

print("Blinking WS2812: Red → Green → Blue")

while True:
    for color in colors:
        np[0] = color
        np.write()
        sleep(0.7)      # Hold each color
        np[0] = OFF
        np.write()
        sleep(0.3)      # Short pause between colors

sudo apt install zfsutils-linux
sudo dd if=/dev/zero of=zfsfile.img bs=1 count=0 seek=10G

sudo zpool create tank /home/peter/zfsfile.img  # have to use full path
sudo zpool status tank

sudo zfs list

sudo zfs set mountpoint=/mnt/myzfs tank
sudo zfs mount tank
df -h

sudo zfs create tank/testdata  # Creates the dataset 'tank/testdata', auto-mounted at /tank/testdata
cd /tank/testdata  # Or /mnt/myzfs/testdata if custom mount
echo "This is file1 content" | sudo tee testfile1  # No need for full 
echo "This is file1 content" | sudo tee /tank/testdata/testfile1
echo "This is file2 content" | sudo tee /tank/testdata/testfile2
ls /tank/testdata

sudo zfs snapshot tank/testdata@test_snapshot
sudo zfs list -t snapshot  # Verify the snapshot exists

sudo zfs send tank/testdata@test_snapshot > /tmp/test_snapshot.zfs
ls -lh /tmp/test_snapshot.zfs  # Check the backup file

cd /tank/testdata
sudo rm testfile1  # Delete a file
echo "Modified file2" | sudo tee testfile2  # Change content
echo "New file3 content" | sudo tee testfile3  # Add new file
ls  # Verify changes: testfile2 testfile3

sudo zfs destroy tank/testdata@test_snapshot
sudo zfs receive -F tank/testdata < /tmp/test_snapshot.zfs
ls testdata

<?xml version="1.0" encoding="UTF-8"?>
<classpath>
  <classpathentry kind="src" path="src/main/java" including="**/*.java"/>
  <classpathentry kind="src" path="target/generated-sources" including="**/*.java"/>
  <classpathentry kind="output" path="target/classes"/>
  <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
  <classpathentry kind="var" path="M2_REPO/org/antlr/antlr4-runtime/4.13.1/antlr4-runtime-4.13.1.jar" sourcepath="M2_REPO/org/antlr/antlr4-runtime/4.13.1/antlr4-runtime-4.13.1-sources.jar"/>
  <classpathentry kind="var" path="M2_REPO/org/ow2/asm/asm/9.6/asm-9.6.jar"/>
  <classpathentry kind="var" path="M2_REPO/org/junit/jupiter/junit-jupiter/5.10.2/junit-jupiter-5.10.2.jar"/>
  <classpathentry kind="var" path="M2_REPO/org/junit/jupiter/junit-jupiter-api/5.10.2/junit-jupiter-api-5.10.2.jar"/>
  <classpathentry kind="var" path="M2_REPO/org/opentest4j/opentest4j/1.3.0/opentest4j-1.3.0.jar"/>
  <classpathentry kind="var" path="M2_REPO/org/junit/platform/junit-platform-commons/1.10.2/junit-platform-commons-1.10.2.jar"/>
  <classpathentry kind="var" path="M2_REPO/org/apiguardian/apiguardian-api/1.1.2/apiguardian-api-1.1.2.jar"/>
  <classpathentry kind="var" path="M2_REPO/org/junit/jupiter/junit-jupiter-params/5.10.2/junit-jupiter-params-5.10.2.jar"/>
  <classpathentry kind="var" path="M2_REPO/org/junit/jupiter/junit-jupiter-engine/5.10.2/junit-jupiter-engine-5.10.2.jar"/>
  <classpathentry kind="var" path="M2_REPO/org/junit/platform/junit-platform-engine/1.10.2/junit-platform-engine-1.10.2.jar"/>
</classpath>

<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
	<name>egg-tart</name>
	<comment>A tiny DSL for stock trading. NO_M2ECLIPSE_SUPPORT: Project files created with the maven-eclipse-plugin are not supported in M2Eclipse.</comment>
	<projects>
	</projects>
	<buildSpec>
		<buildCommand>
			<name>org.eclipse.jdt.core.javabuilder</name>
			<arguments>
			</arguments>
		</buildCommand>
	</buildSpec>
	<natures>
		<nature>org.eclipse.jdt.core.javanature</nature>
	</natures>
	<filteredResources>
		<filter>
			<id>1760958095837</id>
			<name></name>
			<type>30</type>
			<matcher>
				<id>org.eclipse.core.resources.regexFilterMatcher</id>
				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
			</matcher>
		</filter>
	</filteredResources>
</projectDescription>

git clone https://github.com/lvgl-micropython/lvgl_micropython.git
cd lvgl_micropython
# git checkout 15a414bc03486017235234882ce7415532c6325e
docker run -it -v .:/micropython --name micropython ubuntu
apt-get update
export DEBIAN_FRONTEND=noninteractive
apt-get install -y gcc g++ make automake python3 git gcc-arm-none-eabi libusb-1.0-0 python3-venv python3-click python3-yaml cmake vim
ln -s /usr/bin/python3 /usr/bin/python
cd /micropython

# old hardware version: waveshare 3.5
python3 make.py esp32 clean \
  --flash-size=16 \
  BOARD=ESP32_GENERIC_S3 \
  BOARD_VARIANT=SPIRAM_OCT \
  DISPLAY=ST7796 \
  INDEV=ft6x36

# new hardware version: waveshare 3.5b
python3 make.py esp32 clean \
  --flash-size=16 \
  BOARD=ESP32_GENERIC_S3 \
  BOARD_VARIANT=SPIRAM_OCT \
  DISPLAY=axs15231b \
  INDEV=axs15231

exit docker 
 
esptool.py --chip esp32s3 -b 460800 \
    --before default_reset \
    --after hard_reset write_flash \
    --flash_mode dio \
    --flash_size 16MB \
    --flash_freq 80m \
    --erase-all 0x0  \
    build/lvgl_micropy_ESP32_GENERIC_S3-SPIRAM_OCT-16.bin

git clone https://github.com/YosysHQ/icestorm.git icestorm
cd icestorm
make -j$(nproc)
sudo make install
cd ..

git clone https://github.com/cseed/arachne-pnr.git arachne-pnr
cd arachne-pnr
make -j$(nproc)
sudo make install
cd ..

git clone https://github.com/YosysHQ/nextpnr nextpnr
cd nextpnr
cmake .  -B build -DARCH=ice40 -DCMAKE_INSTALL_PREFIX=/usr/local
cd build
make -j$(nproc)
sudo make install
cd ../..

git clone https://github.com/YosysHQ/yosys.git yosys
cd yosys
git submodule update --init
make -j$(nproc)
sudo make install

/* Blink Example

   This example code is in the Public Domain (or CC0 licensed, at your option.)

   Unless required by applicable law or agreed to in writing, this
   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
   CONDITIONS OF ANY KIND, either express or implied.
*/
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "led_strip.h"
#include "sdkconfig.h"

static const char *TAG = "example";

/* Use project configuration menu (idf.py menuconfig) to choose the GPIO to blink,
   or you can edit the following line and set a number here.
*/
#define BLINK_GPIO CONFIG_BLINK_GPIO

static uint8_t s_led_state = 0;
static uint8_t color_phase = 0;  // Phase for color cycling (0-255)

#ifdef CONFIG_BLINK_LED_STRIP

static led_strip_handle_t led_strip;

// Function to create smooth color transitions using HSV to RGB conversion
static void hsv_to_rgb(uint8_t h, uint8_t s, uint8_t v, uint8_t *r, uint8_t *g, uint8_t *b) {
    uint8_t region, remainder, p, q, t;

    if (s == 0) {
        *r = *g = *b = v;
        return;
    }

    region = h / 43;
    remainder = (h - (region * 43)) * 6;

    p = (v * (255 - s)) >> 8;
    q = (v * (255 - ((s * remainder) >> 8))) >> 8;
    t = (v * (255 - ((s * (255 - remainder)) >> 8))) >> 8;

    switch (region) {
        case 0:
            *r = v; *g = t; *b = p;
            break;
        case 1:
            *r = q; *g = v; *b = p;
            break;
        case 2:
            *r = p; *g = v; *b = t;
            break;
        case 3:
            *r = p; *g = q; *b = v;
            break;
        case 4:
            *r = t; *g = p; *b = v;
            break;
        default:
            *r = v; *g = p; *b = q;
            break;
    }
}

static void blink_led(void)
{
    uint8_t r, g, b;
    
    // Convert HSV to RGB for smooth color transitions
    // Hue cycles through full spectrum (0-255)
    // Saturation = 255 (full saturation for vivid colors)
    // Value = 128 (medium brightness)
    hsv_to_rgb(color_phase, 255, 128, &r, &g, &b);
    
    /* Set the LED pixel with the calculated RGB values */
    led_strip_set_pixel(led_strip, 0, r, g, b);
    /* Refresh the strip to send data */
    led_strip_refresh(led_strip);
    
    // Increment color phase for smooth transition
    color_phase += 2;  // Adjust step size for faster/slower color change
}

static void configure_led(void)
{
    ESP_LOGI(TAG, "Example configured to blink addressable LED!");
    /* LED strip initialization with the GPIO and pixels number*/
    led_strip_config_t strip_config = {
        .strip_gpio_num = BLINK_GPIO,
        .max_leds = 1, // at least one LED on board
    };
#if CONFIG_BLINK_LED_STRIP_BACKEND_RMT
    led_strip_rmt_config_t rmt_config = {
        .resolution_hz = 10 * 1000 * 1000, // 10MHz
        .flags.with_dma = false,
    };
    ESP_ERROR_CHECK(led_strip_new_rmt_device(&strip_config, &rmt_config, &led_strip));
#elif CONFIG_BLINK_LED_STRIP_BACKEND_SPI
    led_strip_spi_config_t spi_config = {
        .spi_bus = SPI2_HOST,
        .flags.with_dma = true,
    };
    ESP_ERROR_CHECK(led_strip_new_spi_device(&strip_config, &spi_config, &led_strip));
#else
#error "unsupported LED strip backend"
#endif
    /* Set all LED off to clear all pixels */
    led_strip_clear(led_strip);
}

#elif CONFIG_BLINK_LED_GPIO

static void blink_led(void)
{
    /* Set the GPIO level according to the state (LOW or HIGH)*/
    gpio_set_level(BLINK_GPIO, s_led_state);
}

static void configure_led(void)
{
    ESP_LOGI(TAG, "Example configured to blink GPIO LED!");
    gpio_reset_pin(BLINK_GPIO);
    /* Set the GPIO as a push/pull output */
    gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT);
}

#else
#error "unsupported LED type"
#endif

void app_main(void)
{

    /* Configure the peripheral according to the LED type */
    configure_led();

    while (1) {
        ESP_LOGI(TAG, "Color phase: %d", color_phase);
        blink_led();
        /* Small delay for smooth color transition */
        vTaskDelay(10 / portTICK_PERIOD_MS);  // 10ms delay for smooth animation
    }
}

picocom -b 1500000 /dev/tty.usbserial-A50285BI

import os
import sys
import time
import signal

# Configuration
GPIO_NUMBER = 121  # GPIO3_D1 (physical pin 18)
LOOP_COUNT = 10000000  # Toggle 10 million times (~5-10s)
BASE_PATH = '/sys/class/gpio'

# Global flag for graceful exit
running = True

def signal_handler(sig, frame):
    global running
    print('\nStopping toggle...')
    running = False

signal.signal(signal.SIGINT, signal_handler)

def main():
    # Check if root
    if os.geteuid() != 0:
        print("Error: Run as root (sudo).", file=sys.stderr)
        sys.exit(1)

    gpio_path = f'{BASE_PATH}/gpio{GPIO_NUMBER}'

    # Export GPIO
    if not os.path.exists(gpio_path):
        try:
            with open(f'{BASE_PATH}/export', 'w') as f:
                f.write(str(GPIO_NUMBER))
            time.sleep(0.1)  # Allow setup
        except IOError as e:
            print(f"Error exporting GPIO {GPIO_NUMBER}: {e}", file=sys.stderr)
            sys.exit(1)

    # Set as output
    try:
        with open(f'{gpio_path}/direction', 'w') as f:
            f.write('out')
    except IOError as e:
        print(f"Error setting direction: {e}", file=sys.stderr)
        sys.exit(1)

    # Open value file for fast I/O in binary mode
    try:
        value_file = open(f'{gpio_path}/value', 'wb', buffering=0)
    except IOError as e:
        print(f"Error opening value file: {e}", file=sys.stderr)
        sys.exit(1)

    print(f"Toggling GPIO {GPIO_NUMBER} (GPIO3_D1, physical pin 18)...")
    print(f"Press Ctrl+C to stop.")
    start_time = time.perf_counter()

    count = 0
    while running and (LOOP_COUNT == 0 or count < LOOP_COUNT):
        value_file.write(b'1')  # Write bytes
        value_file.write(b'0')  # Write bytes
        value_file.flush()      # Ensure write
        count += 1

    end_time = time.perf_counter()
    value_file.close()

    # Cleanup
    try:
        with open(f'{BASE_PATH}/unexport', 'w') as f:
            f.write(str(GPIO_NUMBER))
    except IOError:
        pass

    duration = end_time - start_time
    if duration > 0:
        freq_hz = (count * 2) / duration
        print(f"\nCompleted {count} toggles in {duration:.3f}s ({freq_hz:.0f} Hz).")

if __name__ == '__main__':
    main()

dtc -I fs /sys/firmware/devicetree/base | grep -i gpio3

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>

#define SYSFS_GPIO_PATH "/sys/class/gpio"
#define GPIO_NUM 121  // GPIO3_D1

volatile sig_atomic_t running = 1;

void signal_handler(int sig) {
    running = 0;
}

int main() {
    int fd_export, fd_direction, fd_value;
    char path[64];

    // Check if root
    if (geteuid() != 0) {
        fprintf(stderr, "Error: Run as root (sudo).\n");
        return 1;
    }

    // Export GPIO
    snprintf(path, sizeof(path), "%s/export", SYSFS_GPIO_PATH);
    fd_export = open(path, O_WRONLY);
    if (fd_export < 0) {
        perror("Error exporting GPIO");
        return 1;
    }
    dprintf(fd_export, "%d", GPIO_NUM);
    close(fd_export);
    usleep(100000); // Wait for export

    // Set as output
    snprintf(path, sizeof(path), "%s/gpio%d/direction", SYSFS_GPIO_PATH, GPIO_NUM);
    fd_direction = open(path, O_WRONLY);
    if (fd_direction < 0) {
        perror("Error setting direction");
        return 1;
    }
    write(fd_direction, "out", 3);
    close(fd_direction);

    // Open value file
    snprintf(path, sizeof(path), "%s/gpio%d/value", SYSFS_GPIO_PATH, GPIO_NUM);
    fd_value = open(path, O_WRONLY);
    if (fd_value < 0) {
        perror("Error opening value file");
        return 1;
    }

    printf("Toggling GPIO3_D1 (Linux GPIO %d) at ~500 Hz to find physical pin...\n", GPIO_NUM);
    printf("Test pins 15, 16, 18 with oscilloscope. Press Ctrl+C to stop.\n");

    // Slow toggle for testing
    while (running) {
        write(fd_value, "1", 1);
        //usleep(1000); // 1ms
        write(fd_value, "0", 1);
        //usleep(1000); // 1ms
    }

    // Cleanup
    close(fd_value);
    snprintf(path, sizeof(path), "%s/unexport", SYSFS_GPIO_PATH);
    fd_export = open(path, O_WRONLY);
    if (fd_export >= 0) {
        dprintf(fd_export, "%d", GPIO_NUM);
        close(fd_export);
    }

    printf("GPIO3_D1 unexported\n");
    return 0;
}

# Export GPIO 121
echo 121 > /sys/class/gpio/export

# Set as output
echo out > /sys/class/gpio/gpio121/direction

# Toggle manually and check with scope
echo 1 > /sys/class/gpio/gpio121/value
echo 0 > /sys/class/gpio/gpio121/value

# Cleanup
echo 121 > /sys/class/gpio/unexport