MicroCS talks to hardware through one C table, mcs_hal_t (include/mcs_hal.h). A port fills in the functions its chip has; MicroCS turns them into C# classes. You normally do not write the table yourself — pick a port:

Then mcs_hal_open_lib(vm, &hal) (library use) or cfg.hal = &hal (mcs_runtime).

• Static and object APIs. Every peripheral has static methods (GPIO.Write(13, 1), I2C.Read(0, 0x48, 2)); the common ones also have objects that remember their settings (new Pin("PA5", GPIO.Output), new I2cDevice(0, 0x48), new SpiDevice(0, 10, 8_000_000, 0)).
• Pins are numbers or names. Names are resolved by the port ("PA5", "GPIO21", "GP15", "P0.13", "LED", "A0"), so the same script reads naturally on each board. GPIO.Pin("PC13") returns the number.
• Only what exists is registered. If the board has no CAN, there is no CAN class and Hal.Has("CAN") is false — scripts can adapt: if (Hal.Has("DAC")) DAC.Write(0, 2048);. Names for Has: GPIO GPIO.IRQ UART I2C SPI ADC DAC PWM Timer I2S QSPI CAN Watchdog RTC, GPIO.Configure UART.Configure I2C.Configure SPI.Configure QSPI.Configure PWM.Configure ADC.Configure (full configuration objects), DMA DMA.Memory DMA.SPI DMA.I2C DMA.UART DMA.QSPI (transfers that really run in the background), Drivers, and the drivers / classes added by device drivers (ws2812, LedStrip, yours).
• Errors are exceptions. Driver results map to IOException (bus error, NACK), TimeoutException, NotSupportedException (pin/bus not available) and ArgumentException / ArgumentOutOfRangeException (bad values). Catch them like in .NET.
• Transfers are up to MCS_HAL_MAX_XFER (256) bytes per call; data can be byte[], List<byte> or a string. A DmaBuffer has no size limit.
• Configuration objects (API v3). Every peripheral can also be opened with a settings object — pins, pulls, drive strength, filters, DMA and board options: SPI.Open(1, new SpiConfig(20_000_000, 0, 6, 7) { Cs = 10 }), GPIO.Configure(4, new GpioConfig(GPIO.Input, GPIO.PullUp) { Schmitt = true }). Unset properties stay at the board default; settings a board cannot honour throw NotSupportedException with the reason. See Peripheral configuration.
• DMA / asynchronous transfers (API v3). SPI.WriteAsync(1, frame) and friends return a DmaTransfer at once and run in the background where the board has DMA (ESP32, RP2), synchronously elsewhere. See DMA.

Callbacks never run inside the ISR. The driver queues an event (mcs_hal_post(), lock-free and ISR-safe) and the VM runs the C# callback at the next safe point — between statements, during Thread.Sleep, in the REPL loop, or when you call Hal.Poll(). So a handler may allocate, print, use I²C, throw… without any of MicroPython's hard-IRQ restrictions.

var button = new Pin(2, GPIO.InputPullUp);
button.OnChange(GPIO.Falling, (bool level) => Console.WriteLine("pressed"));   // 1 arg: level
GPIO.OnChange(3, GPIO.Both, (int pin, bool level) => { /* 2 args: pin + level */ });
GPIO.Off(3);                                                 // disable

Timer.Start(0, 1000, () => samples.Add(ADC.Read(0)));         // every 1000 µs
Timer.Once(1, 500_000, () => Console.WriteLine("0.5 s later"));
UART.OnReceive(1, (int available) => Console.Write(UART.ReadString(1, available)));
CAN.OnReceive(0, (int pending) => { CanFrame f; while ((f = CAN.Receive(0)) != null) Handle(f); });

Hal.OnEvent(5, (int source, int value) => { });               // your own C events:
// C side: mcs_hal_post(MCS_HAL_EV_USER + 5, source, value);  (from any ISR)
Hal.Run(10_000);                                              // dispatch events for 10 s

Up to MCS_HAL_MAX_CALLBACKS (16) handlers; the queue holds MCS_HAL_EVENT_QUEUE (32) events, overflow is counted in Hal.DroppedEvents. When you drive the VM yourself, call mcs_hal_poll(vm) from your main loop (the runtime, the shell and the scheduler already do).

Optional arguments are shown in [brackets].

LedStrip comes from the built-in ws2812 driver (DRIVERS.md): it is registered when the build has it (MCS_ENABLE_WS2812, CMake -DMICROCS_WS2812=OFF turns it off) and the port provides a backend — Hal.Has("LedStrip") / Drivers.Has("ws2812") tell. A firmware can replace the backend (e.g. SPI + DMA) with mcs_driver_register.

Servo comes from the built-in servo driver (DRIVERS.md): the default backend is the board's PWM at 50 Hz, so it works wherever PWM does (and in the simulator); a firmware can register another backend (PCA9685, servo bus). Hal.Has("Servo") / Drivers.Has("servo") tell; MCS_ENABLE_SERVO 0 (CMake -DMICROCS_SERVO=OFF) leaves it out.

var pan = new Servo(0);            // PWM channel 0
pan.Angle = 90;                    // centre
pan.MoveTo(180, 1000);             // sweep in 1 s

Encoding.UTF8 / Encoding.ASCII (GetBytes, GetString(bytes[, index, count]), GetByteCount) and little-endian BitConverter (GetBytes, ToInt16, ToUInt16, ToInt32, ToUInt32, ToInt64, ToSingle, ToDouble, ToBoolean, ToString → "01-AB-FF") are registered together with the HAL — they are what drivers need for packets.

Fill only what your hardware has; every member is optional. Functions return >= 0 on success or a negative MCS_HAL_E* code.

#include "mcs_hal.h"

static int my_mode(void* ctx, int pin, int mode) { gpio_config(pin, mode); return 0; }
static int my_write(void* ctx, int pin, int v)   { gpio_set(pin, v); return 0; }
static int my_read(void* ctx, int pin)           { return gpio_get(pin); }
static int my_irq(void* ctx, int pin, int edge)  { exti_enable(pin, edge); return 0; }

void EXTI_IRQHandler(void) {                      /* your interrupt */
    int pin = exti_pending_pin();
    mcs_hal_post(MCS_HAL_EV_GPIO, pin, gpio_get(pin));   /* ISR-safe */
}

static const mcs_hal_t board = {
    .board = "my-board",
    .gpio_mode = my_mode, .gpio_write = my_write, .gpio_read = my_read, .gpio_irq = my_irq,
    .i2c_write = my_i2c_write, .i2c_read = my_i2c_read,
    .adc_read = my_adc, .adc_bits = 12,
};
mcs_hal_open_lib(vm, &board);

Events can also be delivered from an RTOS queue via .poll_event instead of mcs_hal_post (the ESP32 port does this). ports/template/mcs_port_template.c lists every member with a stub. Board tables written for HAL v1 (1.3) compile unchanged. API v3 (1.12) adds optional members: *_configure for the configuration objects plus a options table (Peripheral configuration), and dma_alloc / dma_copy / spi_transfer_async … for background transfers (DMA). Boards without them keep working: the library falls back to *_open and synchronous transfers. Devices on top of the board (LED strips, displays, sensors ...) are not HAL members but drivers: a C# front end plus a per-MCU backend, registered with mcs_driver_register.

./mcs --sim and the tests use mcs_hal_sim_init(): 64 GPIOs (outputs read back; an output with an interrupt fires on its own edges), UART loopback, I²C devices at 0x48 (TMP102, 25 °C), 0x50 (256-byte EEPROM) and 0x68 (register file, WHO_AM_I = 0x68), SPI loopback, 12-bit ADC/DAC, PWM, 4 timers, I²S loopback, CAN loopback and a 4 KB QSPI NOR flash (JEDEC EF 40 16). --sim-log traces every access; --sim-virtual uses a deterministic clock.