### Configure and Use Hardware Timers in C

Source: https://context7.com/devkitpro/libgba/llms.txt

This C code demonstrates how to initialize and utilize the four hardware timers available on the GBA. It shows setting up timers for CPU cycle counting, cascading timers, audio sample rates, and handling timer overflow interrupts. It also includes VBlank interrupt handling and basic screen setup.

```c
#include <gba.h>

volatile u32 elapsed_frames = 0;
volatile u32 timer_overflows = 0;

void timer0_handler(void) {
    timer_overflows++;
}

int main(void) {
    irqInit();
    irqSet(IRQ_VBLANK, NULL);
    irqSet(IRQ_TIMER0, timer0_handler);
    irqEnable(IRQ_VBLANK | IRQ_TIMER0);

    // Timer 0: Count CPU cycles (16.78MHz)
    // Overflow at 65536 cycles = ~256 overflows per second
    REG_TM0CNT_L = 0;
    REG_TM0CNT_H = TIMER_START | TIMER_IRQ;

    // Timer 1: Cascade from Timer 0 (counts Timer 0 overflows)
    REG_TM1CNT_L = 0;
    REG_TM1CNT_H = TIMER_START | TIMER_COUNT;

    // Timer for audio sample rate (example: ~32768 Hz)
    // 16.78MHz / 512 prescaler = 32768 Hz
    REG_TM2CNT_L = 65536 - 512;  // Overflow every 512 cycles
    REG_TM2CNT_H = TIMER_START;

    SetMode(MODE_0 | BG0_ON);

    while(1) {
        u16 timer0_val = REG_TM0CNT_L;
        u16 timer1_val = REG_TM1CNT_L;

        // Calculate elapsed time in milliseconds
        u32 total_cycles = ((u32)timer1_val << 16) | timer0_val;
        u32 milliseconds = total_cycles / 16780;

        VBlankIntrWait();
        elapsed_frames++;
    }
}
```

--------------------------------

### Sound System Configuration in C for GBA

Source: https://context7.com/devkitpro/libgba/llms.txt

Details the setup and configuration of the Game Boy Advance's sound system. This code snippet shows how to enable the sound system, configure the four DMG channels (two square, one wave, one noise), and set up the two direct sound channels for PCM audio playback. It also demonstrates playing a sound effect on button press. Requires the gba.h header.

```c
#include <gba.h>

int main(void) {
    irqInit();
    irqEnable(IRQ_VBLANK);

    // Enable sound system
    SNDSTAT = SNDSTAT_ENABLE;

    // Configure DMG sound output
    DMGSNDCTRL = DMGSNDCTRL_LVOL(7) | DMGSNDCTRL_RVOL(7) |
                 DMGSNDCTRL_LSQR1 | DMGSNDCTRL_RSQR1 |
                 DMGSNDCTRL_LSQR2 | DMGSNDCTRL_RSQR2;

    // Configure Direct Sound
    DSOUNDCTRL = DSOUNDCTRL_DMG100 | DSOUNDCTRL_A100 |
                 DSOUNDCTRL_AL | DSOUNDCTRL_AR |
                 DSOUNDCTRL_ATIMER(0) | DSOUNDCTRL_ARESET;

    // Square wave channel 1
    SQR1SWEEP = SQR1SWEEP_OFF;  // No frequency sweep
    SQR1CTRL = SQR_DUTY(2) | SQR_VOL(15);  // 50% duty, max volume
    SQR1FREQ = TRIFREQ_RESET | TRIFREQ_TIMED | 1046;  // ~440Hz (A4)

    // Square wave channel 2
    SQR2CTRL = SQR_DUTY(1) | SQR_VOL(12);  // 25% duty
    SQR2FREQ = TRIFREQ_RESET | TRIFREQ_HOLD | 1546;  // Different pitch

    // Triangle/Wave channel
    TRICTRL = TRICTRL_1X64 | TRICTRL_BANK(0) | TRICTRL_ENABLE;

    // Load wave pattern (sine wave approximation)
    TRIWAVERAM[0] = 0x10325476;
    TRIWAVERAM[1] = 0x98BADCFE;
    TRIWAVERAM[2] = 0xEFCDAB89;
    TRIWAVERAM[3] = 0x67452301;

    TRILENVOL = TRILENVOL_100;  // Full volume
    TRIFREQ = TRIFREQ_RESET | TRIFREQ_HOLD | 1800;

    SetMode(MODE_0 | BG0_ON);

    while(1) {
        scanKeys();

        // Play sound on button press
        if (keysDown() & KEY_A) {
            SQR1FREQ = TRIFREQ_RESET | TRIFREQ_TIMED | 1046;
        }

        VBlankIntrWait();
    }
}
```

--------------------------------

### File Operations (C)

Source: https://github.com/devkitpro/libgba/blob/master/src/mbv2.txt

Supports standard file I/O operations on the PC from the GBA, including opening, closing, reading, writing, and seeking within files. Functions like `dfopen`, `dfclose`, `dfprintf`, `dfgetc`, `dfputc`, and `drewind` are provided. Note that only one file can be open at a time, and `dfputc` is recommended for binary data.

```c
#include "mbv2lib.c"

int main (void)
{
    FILE fp;

    // Copy SRAM or Flash backup to PC
    fp = dfopen("sram.bin","wb");
    for (int i = 0; i != 0x8000; i++)
       dfputc(*(unsigned char *)(i + 0xE000000), fp);
    dfclose(fp);

    // Copy PC to SRAM
    fp = dfopen("sram.bin","rb");
    for (int i = 0; i != 0x8000; i++)
       *(unsigned char *)(i + 0xE000000) = dfgetc (fp);
    dfclose(fp);

    // Read data from file
    fp = dfopen ("foo.bin", "rb");
    int i = dfgetc (fp);
    int j = dfgetc (fp);
    int k = dfgetc (fp);
    dfclose (fp);

    return 0;
}
```

--------------------------------

### GBA Interrupt Handling: VBlank and Timer (C)

Source: https://context7.com/devkitpro/libgba/llms.txt

Shows how to initialize and manage hardware interrupts in libgba, specifically VBlank and Timer interrupts. It includes setting up interrupt handlers and enabling them. Requires the gba.h header.

```c
#include <gba.h>

volatile int frame_count = 0;

void vblank_handler(void) {
    frame_count++;
}

void timer_handler(void) {
    // Handle timer overflow
}

int main(void) {
    // Initialize interrupt system
    irqInit();

    // Set VBlank handler and enable it
    irqSet(IRQ_VBLANK, vblank_handler);
    irqEnable(IRQ_VBLANK);

    // Enable LCD VBlank interrupt flag
    REG_DISPSTAT |= LCDC_VBL;

    // Set timer interrupt
    irqSet(IRQ_TIMER0, timer_handler);
    irqEnable(IRQ_TIMER0);

    // Configure and start timer 0
    REG_TM0CNT_L = 0;                           // Initial count
    REG_TM0CNT_H = TIMER_IRQ | TIMER_START;     // Enable IRQ and start

    SetMode(MODE_0 | BG0_ON);

    while(1) {
        VBlankIntrWait();  // Wait for VBlank interrupt
        // Game logic runs after VBlank
    }
}
```

--------------------------------

### Implement Affine Transformations for Backgrounds and Sprites in C

Source: https://context7.com/devkitpro/libgba/llms.txt

This C code demonstrates how to apply affine transformations (rotation, scaling) to backgrounds and sprites using libgba's BIOS functions. It shows setting up source structures for background and sprite transformations, configuring sprite attributes, and updating the transformation matrices in a loop based on user input (shoulder buttons for rotation, D-pad for scaling).

```c
#include <gba.h>

int main(void) {
    irqInit();
    irqEnable(IRQ_VBLANK);

    SetMode(MODE_1 | BG2_ON | OBJ_ON | OBJ_1D_MAP);

    // Background affine transformation
    BGAffineSource bg_src = {
        .x = 128 << 8,      // Center X (8-bit fixed point)
        .y = 128 << 8,      // Center Y
        .tX = SCREEN_WIDTH / 2,   // Screen center X
        .tY = SCREEN_HEIGHT / 2,  // Screen center Y
        .sX = 0x100,        // Scale X (1.0 in 8-bit fixed point)
        .sY = 0x100,        // Scale Y
        .theta = 0          // Rotation angle
    };
    BGAffineDest bg_dst;

    // Sprite affine transformation
    ObjAffineSource obj_src = {
        .sX = 0x100,        // Scale X (1.0)
        .sY = 0x100,        // Scale Y
        .theta = 0          // Rotation
    };

    // Configure affine sprite (sprite 0)
    OAM[0].attr0 = OBJ_Y(72) | OBJ_ROT_SCALE_ON | OBJ_DOUBLE | OBJ_16_COLOR | OBJ_SQUARE;
    OAM[0].attr1 = OBJ_X(112) | OBJ_ROT_SCALE(0) | OBJ_SIZE(1);  // 16x16, matrix 0
    OAM[0].attr2 = OBJ_CHAR(0) | OBJ_PALETTE(0);

    u16 angle = 0;
    s16 scale = 0x100;

    while(1) {
        scanKeys();

        // Rotate with shoulder buttons
        if (keysHeld() & KEY_L) angle -= 0x200;
        if (keysHeld() & KEY_R) angle += 0x200;

        // Scale with D-pad
        if (keysHeld() & KEY_UP) scale += 4;
        if (keysHeld() & KEY_DOWN) scale -= 4;
        if (scale < 0x40) scale = 0x40;
        if (scale > 0x400) scale = 0x400;

        // Update sprite affine matrix
        obj_src.theta = angle;
        obj_src.sX = scale;
        obj_src.sY = scale;
        ObjAffineSet(&obj_src, (void*)&OAM[0].dummy, 1, 8);  // Update matrix in OAM

        // Update background affine matrix
        bg_src.theta = angle;
        bg_src.sX = scale;
        bg_src.sY = scale;
        BgAffineSet(&bg_src, &bg_dst, 1);

        // Apply to BG2 affine registers
        REG_BG2PA = bg_dst.pa;
        REG_BG2PB = bg_dst.pb;
        REG_BG2PC = bg_dst.pc;
        REG_BG2PD = bg_dst.pd;
        REG_BG2X = bg_dst.x;
        REG_BG2Y = bg_dst.y;

        VBlankIntrWait();
    }
}
```

--------------------------------

### GBA Video Display Control: Modes and Backgrounds (C)

Source: https://context7.com/devkitpro/libgba/llms.txt

Demonstrates setting display modes (bitmap and tiled) and configuring background layers using libgba. It shows direct framebuffer manipulation for Mode 3 and setting up tiled backgrounds with scrolling for Mode 0. Requires the gba.h header.

```c
#include <gba.h>

int main(void) {
    // Initialize Mode 3 (240x160 bitmap, 15-bit color)
    SetMode(MODE_3 | BG2_ON);

    // Direct framebuffer access
    MODE3_FB[80][120] = RGB5(31, 0, 0);   // Red pixel at center
    MODE3_FB[80][121] = RGB5(0, 31, 0);   // Green pixel
    MODE3_FB[80][122] = RGB5(0, 0, 31);   // Blue pixel

    // Mode 0 with multiple tiled backgrounds
    SetMode(MODE_0 | BG0_ON | BG1_ON | OBJ_ON | OBJ_1D_MAP);

    // Configure background 0
    REG_BG0CNT = BG_256_COLOR | BG_SIZE_0 | CHAR_BASE(0) | SCREEN_BASE(31);

    // Set scroll offset
    REG_BG0HOFS = 0;
    REG_BG0VOFS = 0;

    // Set palette colors
    BG_PALETTE[0] = RGB5(0, 0, 0);     // Background color (black)
    BG_PALETTE[1] = RGB5(31, 31, 31);  // Foreground color (white)

    while(1) {
        VBlankIntrWait();
    }
}
```

--------------------------------

### Sprite Management using OAM in C

Source: https://context7.com/devkitpro/libgba/llms.txt

Demonstrates how to initialize and manage sprites on the Game Boy Advance using Object Attribute Memory (OAM). It covers copying sprite tile data to VRAM, setting up palettes, configuring sprite attributes (position, size, shape, flip), and updating sprite positions dynamically based on user input. Requires the gba.h header.

```c
#include <gba.h>

// Sprite tile data (8x8 pixels, 4bpp = 32 bytes)
const u32 sprite_tiles[] = {
    0x11111111, 0x12222221, 0x12333321, 0x12344321,
    0x12344321, 0x12333321, 0x12222221, 0x11111111
};

int main(void) {
    irqInit();
    irqEnable(IRQ_VBLANK);

    SetMode(MODE_0 | OBJ_ON | OBJ_1D_MAP);

    // Copy sprite tile data to VRAM
    dmaCopy(sprite_tiles, SPRITE_GFX, sizeof(sprite_tiles));

    // Set sprite palette
    SPRITE_PALETTE[0] = RGB5(31, 0, 31);  // Transparent (magenta)
    SPRITE_PALETTE[1] = RGB5(0, 0, 0);    // Black outline
    SPRITE_PALETTE[2] = RGB5(31, 31, 31); // White
    SPRITE_PALETTE[3] = RGB5(31, 0, 0);   // Red
    SPRITE_PALETTE[4] = RGB5(0, 31, 0);   // Green

    // Configure sprite 0
    OAM[0].attr0 = OBJ_Y(80) | OBJ_16_COLOR | OBJ_SQUARE;
    OAM[0].attr1 = OBJ_X(120) | OBJ_SIZE(0);  // 8x8 sprite
    OAM[0].attr2 = OBJ_CHAR(0) | OBJ_PALETTE(0) | OBJ_PRIORITY(0);

    // Configure sprite 1: 16x16 with horizontal flip
    OAM[1].attr0 = OBJ_Y(100) | OBJ_16_COLOR | OBJ_SQUARE;
    OAM[1].attr1 = OBJ_X(140) | OBJ_SIZE(1) | OBJ_HFLIP;  // 16x16
    OAM[1].attr2 = OBJ_CHAR(1) | OBJ_PALETTE(0);

    // Hide remaining sprites
    for (int i = 2; i < 128; i++) {
        OAM[i].attr0 = OBJ_DISABLE;
    }

    int sprite_x = 120;

    while(1) {
        scanKeys();

        if (keysHeld() & KEY_LEFT) sprite_x--;
        if (keysHeld() & KEY_RIGHT) sprite_x++;

        // Update sprite position (modify only X position bits)
        OAM[0].attr1 = (OAM[0].attr1 & ~0x1FF) | OBJ_X(sprite_x);

        VBlankIntrWait();
    }
}
```

--------------------------------

### Utilize GBA BIOS System and Math Functions

Source: https://context7.com/devkitpro/libgba/llms.txt

Demonstrates the use of GBA BIOS functions for optimized mathematical operations (division, square root, arctangent) and system control (memory operations, reset, halt). These functions execute from BIOS ROM for speed.

```c
#include <gba.h>

int main(void) {
    irqInit();
    irqEnable(IRQ_VBLANK);

    // Division (faster than software division)
    s32 quotient = Div(1000, 7);      // Returns 142
    s32 remainder = DivMod(1000, 7);  // Returns 6
    u32 abs_quot = DivAbs(-1000, 7);  // Returns 142 (absolute)

    // ARM mode division (arguments swapped)
    s32 result = DivArm(7, 1000);     // Note: divisor first!

    // Square root
    u16 root = Sqrt(144);  // Returns 12

    // Arctangent
    s16 angle = ArcTan(0x100);        // Tan value in 1.14 fixed point
    u16 angle2 = ArcTan2(100, 50);    // Returns angle for vector (100, 50)

    // Fast memory operations
    u32 source[256];
    u32 dest[256];

    // CpuSet: Copy 256 words
    CpuSet(source, dest, COPY32 | 256);

    // CpuSet: Fill memory with a value
    u32 fill_value = 0xDEADBEEF;
    CpuSet(&fill_value, dest, FILL | COPY32 | 256);

    // CpuFastSet: Faster but requires 32-byte aligned, multiples of 8 words
    CpuFastSet(source, dest, COPY32 | 256);

    // System control
    u32 checksum = BiosCheckSum();  // Verify BIOS integrity

    // Halt CPU until interrupt
    Halt();

    // Deep sleep (stops CPU and LCD)
    // Stop();  // Uncommonly used

    // Soft reset
    // SoftReset(ROM_RESTART);  // Reset to ROM entry

    // Reset specific memory regions
    RegisterRamReset(RESET_VRAM | RESET_OAM | RESET_PALETTE);

    SetMode(MODE_0 | BG0_ON);

    while(1) {
        VBlankIntrWait();
    }
}

```

--------------------------------

### GBA Input Handling: Button States and Repeat (C)

Source: https://context7.com/devkitpro/libgba/llms.txt

Illustrates how to read button states using libgba's input functions. It covers detecting button presses, releases, held states, and setting up key repeat functionality. Requires the gba.h header.

```c
#include <gba.h>

int main(void) {
    int player_x = 120, player_y = 80;

    irqInit();
    irqEnable(IRQ_VBLANK);

    // Set key repeat rate: 30 frames delay, then repeat every 5 frames
    setRepeat(30, 5);

    SetMode(MODE_3 | BG2_ON);

    while(1) {
        scanKeys();  // Must call each frame

        u16 keys_pressed = keysDown();      // Just pressed this frame
        u16 keys_released = keysUp();       // Just released this frame
        u16 keys_current = keysHeld();      // Currently held
        u16 keys_repeat = keysDownRepeat(); // With auto-repeat

        // Movement with D-pad
        if (keys_current & KEY_UP)    player_y--;
        if (keys_current & KEY_DOWN)  player_y++;
        if (keys_current & KEY_LEFT)  player_x--;
        if (keys_current & KEY_RIGHT) player_x++;

        // Action buttons - single press detection
        if (keys_pressed & KEY_A) {
            // Fire action (only triggers once per press)
        }

        if (keys_pressed & KEY_B) {
            // Jump action
        }

        // Shoulder buttons
        if (keys_current & KEY_L) {
            // Strafe left
        }
        if (keys_current & KEY_R) {
            // Strafe right
        }

        // Start/Select
        if (keys_pressed & KEY_START) {
            // Pause game
        }

        VBlankIntrWait();
    }
}
```

--------------------------------

### DMA Transfers in C for GBA

Source: https://context7.com/devkitpro/libgba/llms.txt

Illustrates the use of Direct Memory Access (DMA) for efficient data transfers on the Game Boy Advance. This snippet shows how to copy data between buffers, fill screen memory with a specific color, and set up DMA for audio playback. It utilizes the gba.h library and demonstrates both direct register manipulation and the `dmaCopy` helper function.

```c
#include <gba.h>

u16 source_buffer[240];
u16 double_buffer[160][240];

int main(void) {
    irqInit();
    irqEnable(IRQ_VBLANK);

    SetMode(MODE_3 | BG2_ON);

    // Fill source buffer with gradient
    for (int i = 0; i < 240; i++) {
        source_buffer[i] = RGB5(i >> 3, 0, 0);
    }

    // DMA3 copy: Copy 240 halfwords to first scanline
    DMA3COPY(source_buffer, MODE3_FB[0], DMA16 | 240);

    // Using dmaCopy helper function (uses DMA3, 16-bit)
    dmaCopy(source_buffer, MODE3_FB[1], 240 * sizeof(u16));

    // Fill screen with a color using DMA fill mode
    u16 fill_color = RGB5(0, 15, 31);
    REG_DMA3SAD = (u32)&fill_color;
    REG_DMA3DAD = (u32)MODE3_FB[50];
    REG_DMA3CNT = DMA_ENABLE | DMA_SRC_FIXED | DMA16 | (240 * 60);  // Fill 60 lines

    // DMA for sound: Set up DMA1 for Direct Sound A
    REG_DMA1SAD = (u32)audio_samples;
    REG_DMA1DAD = (u32)&REG_FIFO_A;
    REG_DMA1CNT = DMA_ENABLE | DMA_SPECIAL | DMA_REPEAT | DMA32 |
                  DMA_SRC_INC | DMA_DST_FIXED | 1;

    while(1) {
        VBlankIntrWait();
    }
}
```

--------------------------------

### Console Output Functions (C)

Source: https://github.com/devkitpro/libgba/blob/master/src/mbv2.txt

Provides functions to print strings and characters to the PC console. These functions are part of the MB V2 library and require the library to be included in the GBA project. They map to standard C functions like printf and putchar.

```c
#include "mbv2lib.c"

int main (void)
{
    dprintf ("Hello world!");
    return 0;
}
```

--------------------------------

### Console Text Output with ANSI Codes in C

Source: https://context7.com/devkitpro/libgba/llms.txt

This C code demonstrates how to use the libgba console system for text output. It covers initializing the console, clearing the screen, printing text at specific positions, using ANSI escape codes for colors, and standard printf formatting. It also includes basic input handling for A and B buttons.

```c
#include <gba.h>
#include <stdio.h>

int main(void) {
    irqInit();
    irqEnable(IRQ_VBLANK);

    // Initialize console with default settings
    consoleDemoInit();

    // Clear screen
    printf(CON_CLS());

    // Print at specific position
    printf(CON_POS(1, 1) "libgba Console Demo");
    printf(CON_POS(1, 3) "Frame: 0");

    // Use ANSI colors
    printf(CONSOLE_RED "Red text\n" CONSOLE_RESET);
    printf(CONSOLE_GREEN "Green text\n" CONSOLE_RESET);
    printf(CONSOLE_BLUE "Blue text\n" CONSOLE_RESET);
    printf(CONSOLE_YELLOW "Yellow text\n" CONSOLE_RESET);

    // Standard printf formatting
    int score = 12345;
    printf("Score: %d\n", score);
    printf("Hex: 0x%08X\n", score);

    u32 frame = 0;
    while(1) {
        scanKeys();

        // Update frame counter display
        printf(CON_POS(8, 3) "%lu", frame);

        if (keysDown() & KEY_A) {
            printf(CON_POS(1, 10) "A pressed!  ");
        }
        if (keysDown() & KEY_B) {
            printf(CON_POS(1, 10) "B pressed!  ");
        }

        VBlankIntrWait();
        frame++;
    }
}
```

--------------------------------

### Keyboard Input Functions (C)

Source: https://github.com/devkitpro/libgba/blob/master/src/mbv2.txt

Enables reading character input from the PC keyboard within a GBA application. The `dgetch` function waits for and returns a single character, while `dkbhit` checks if a character is available without blocking. These functions are crucial for interactive GBA programs communicating with a PC.

```c
#include "mbv2lib.c"

int main (void)
{
    int i;
    i = dgetch (); // Get character from PC keyboard
    return 0;
}
```

--------------------------------

### Decompress Data using GBA BIOS Functions

Source: https://context7.com/devkitpro/libgba/llms.txt

Demonstrates decompression of LZ77, RLE, and Huffman compressed data using GBA BIOS functions. Requires data to be pre-compressed with matching algorithms. Supports decompression to WRAM or VRAM.

```c
#include <gba.h>

// LZ77 compressed data (created with grit or gbacomp)
extern const u8 compressed_tiles[];
extern const u8 compressed_tiles_end[];

// RLE compressed palette
extern const u8 compressed_palette[];

// Uncompressed destination buffers
u8 tile_buffer[4096] __attribute__((aligned(4)));

int main(void) {
    irqInit();
    irqEnable(IRQ_VBLANK);

    // LZ77 decompress to WRAM (for general data)
    LZ77UnCompWram(compressed_tiles, tile_buffer);

    // LZ77 decompress directly to VRAM (16-bit writes only)
    LZ77UnCompVram(compressed_tiles, (void*)CHAR_BASE_ADR(0));

    // RLE decompress to WRAM
    RLUnCompWram(compressed_palette, (void*)BG_PALETTE);

    // Huffman decompress
    HuffUnComp(huffman_data, destination_buffer);

    // Bit unpacking (expand 1bpp font to 4bpp)
    BUP unpack_params = {
        .SrcNum = 8,           // 8 bytes source
        .SrcBitNum = 1,        // 1 bit per pixel source
        .DestBitNum = 4,       // 4 bits per pixel destination
        .DestOffset = 0,       // No offset added
        .DestOffset0_On = 0    // Don't add offset to 0 values
    };
    BitUnPack(font_1bpp, font_4bpp, &unpack_params);

    // Differential filter decompression (for graphics with gradients)
    Diff8bitUnFilterWram(diff_compressed_data, output_buffer);
    Diff16bitUnFilter(diff16_compressed_data, output_buffer);

    SetMode(MODE_0 | BG0_ON);

    while(1) {
        VBlankIntrWait();
    }
}

```

--------------------------------

### Data Transfer Format (PC -> GBA)

Source: https://github.com/devkitpro/libgba/blob/master/src/mbv2.txt

Outlines the data transfer format for PC to GBA communication, covering file read data and keyboard input. ESCCHR (0x00) is used for polling, ESCCHR (0x01) for escape characters from PC file reads, and ESCCHR (0x08) followed by data for keyboard input.

```text
PC -> GBA Comms:
Raw data is PC File read data.
ESCCHR 0x00 = nada (used for input polling)
ESCCHR 0x01 = Escape character from PC file read
ESCCHR 0x08 0x?? = Keyboard read data
```

--------------------------------

### Data Transfer Format (GBA -> PC)

Source: https://github.com/devkitpro/libgba/blob/master/src/mbv2.txt

Defines the escape sequences used for GBA to PC communication, primarily for console output and file operations. Special characters like ESCCHR (0x01) are used to signal commands such as file open, close, read, and write, along with data payloads.

```text
GBA -> PC comms
Raw data is console print data.
ESCCHR = escape sequence
ESCCHR 0x00 = nada (used for input polling)
ESCCHR 0x01 = Escape character for console print
ESCCHR 0x02 = file open (gba -> PC)
ESCCHR 0x03 = file close (gba -> PC)
ESCCHR 0x04 = fgetc (gba -> PC)
ESCCHR 0x05 0x?? = fputc (gba -> PC)
ESCCHR 0x06 = rewind (gba -> PC)
ESCCHR 0x07 = fputc processed (gba -> pC) (Add CR before LF char if win/DOS machine)
```

--------------------------------

### Configure and Use Serial Communication Modes on GBA

Source: https://context7.com/devkitpro/libgba/llms.txt

Configures and utilizes various serial communication modes on the Game Boy Advance, including multiplayer, normal 8/32-bit, and UART. Requires interrupt handlers for serial events.

```c
#include <gba.h>

int main(void) {
    irqInit();
    irqSet(IRQ_SERIAL, serial_handler);
    irqEnable(IRQ_VBLANK | IRQ_SERIAL);

    // Configure for multiplayer mode
    REG_RCNT = R_MULTI;
    REG_SIOCNT = SIO_MULTI | SIO_IRQ;

    // Normal 8-bit mode (for simple serial)
    REG_RCNT = R_NORMAL;
    REG_SIOCNT = SIO_8BIT | SIO_CLK_INT | SIO_IRQ;

    // UART mode at 115200 baud
    REG_RCNT = R_UART;
    REG_SIOCNT = SIO_UART | SIO_115200 | SIO_IRQ;

    SetMode(MODE_0 | BG0_ON);

    while(1) {
        scanKeys();

        // Check multiplayer status
        u16 status = REG_SIOCNT;
        int player_id = (status >> 4) & 3;  // 0 = master, 1-3 = slaves

        // Send data in multiplayer mode
        REG_SIOMLT_SEND = 0x1234;
        REG_SIOCNT |= SIO_START;  // Start transfer (master only)

        // Wait for transfer complete
        while (REG_SIOCNT & SIO_START);

        // Read received data from all players
        u16 data0 = REG_SIOMULTI0;  // Master data
        u16 data1 = REG_SIOMULTI1;  // Slave 1 data
        u16 data2 = REG_SIOMULTI2;  // Slave 2 data
        u16 data3 = REG_SIOMULTI3;  // Slave 3 data

        VBlankIntrWait();
    }
}

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.