vanty120/edgecoder-rpi5-c-sft-v1

Dataset Card for EdgeCoder RPi5 C SFT v1

Dataset Summary

EdgeCoder RPi5 C SFT v1 is an instruction-tuning dataset for teaching small language models to write correct, current C code for Raspberry Pi 5 (Raspberry Pi OS / Debian 13, Linux userspace, gcc 14). It covers five peripheral families:

Peripheral	Interface
GPIO	libgpiod v2
I2C	i2c-dev SMBus
SPI	spidev
UART	termios
PWM	sysfs

Small open models perform poorly on this domain. In the project's baseline evaluation, five 1.5–3.7B models reached 0.8–5.0% pass@1, and none solved a single GPIO or I2C task. They typically used deprecated interfaces (libgpiod v1, /sys/class/gpio, wiringPi, pigpio) or APIs that do not exist.

This dataset targets those failure modes. Every assistant answer was compiled, scanned for deprecated APIs, and executed against a simulated device before it was kept.

Examples	1,357 (train 1,278 / validation 79)
Distinct tasks	386
Languages	English 683, Vietnamese 674
Verification level	100% behaviour-tested (L3)
Median answer length	346 tokens

Supported Tasks

• Code generation (supervised fine-tuning). Write one C function from a natural-language specification and a given signature.
• Legacy code migration. Port code written for older Raspberry Pi setups (wiringPi, sysfs GPIO, libgpiod v1, /dev/mem) to Raspberry Pi 5.
• Self-repair. Revise a failed attempt using compiler and test feedback, for agentic generate–verify–fix loops.

Languages

Task descriptions are in English (en) or Vietnamese (vi). Code, identifiers and the format instruction are in English. Self-repair feedback messages come from the verifier and are in Vietnamese.

Dataset Structure

Data Instances

{
  "messages": [
    {"role": "system", "content": "You are an expert embedded Linux C programmer. Target platform: Raspberry Pi 5, Raspberry Pi OS (Debian 13 Trixie, 64-bit), gcc 14, C11 (gnu11), Linux userspace."},
    {"role": "user", "content": "Init push-button with in-chip pull-up: open chip_path (caller-provided, never hard-code), line offset 0-based ...\n\nFunction signature:\nstruct gpiod_line_request *init_button_pullup(const char *chip_path, unsigned int offset);\n\nReply with exactly one ```c code block ..."},
    {"role": "assistant", "content": "```c\n#include <gpiod.h>\n...\n```"}
  ],
  "meta": {
    "id": "ecv1-t_gpio_0005-single-en-short-25", "task_id": "t_gpio_0005", "kind": "single", "lang": "en",
    "prompt_style": "short", "category": "gpio", "difficulty": "easy", "type": "init", "verify_level": "L3",
    "solution_source": "reference", "generator": "muse-spark-1.3-contributor", "harness_version": "0.3.0",
    "source": "generated", "license": "cc-by-4.0", "train_on": "all_assistant", "answer_tokens": 469,
    "total_tokens": 712
  }
}

Data Fields

• messages: list of {role, content} turns (system, user, assistant), ready for apply_chat_template. Assistant answers are exactly one fenced C code block.
• meta.task_id: source task. Several examples can share one task, using different prompts or solutions.
• meta.kind:
  • single: task description to code (911 examples).
  • migration: legacy code plus requirements to Raspberry Pi 5 code (103).
  • repair: multi-turn dialogue of task, failed attempt, verifier feedback, fixed code (343).
• meta.train_on: which assistant turns to train on.
  • all_assistant for single-turn examples.
  • last_assistant for repair examples, whose first assistant turn is an incorrect attempt and must be masked out of the loss.
• meta.lang: en or vi.
• meta.prompt_style:
  • detailed: full specification.
  • short: concise engineer-style note that keeps every constant but omits API hints.
  • legacy_code: the migration prompt.
• meta.category: gpio, i2c, spi, uart or pwm.
• meta.difficulty: easy, medium or hard.
• meta.type: init, read_write, error_handling or event.
• meta.solution_source: reference, alternate (a second correct implementation in a different style), or indep (written from the description alone, without seeing the test).
• meta.student_failed_layer: for repair only. The verification layer at which the original attempt failed (1 = compile/link, 3 = behaviour).
• meta.verify_level, meta.harness_version: verification depth and verifier version.
• meta.generator: model that produced the task text and solutions.
• meta.answer_tokens, meta.total_tokens: lengths under the Ministral 3 tokenizer.

Data Splits

Split	Examples	Tasks
train	1,278	364
validation	79	22

Splits are made by task, so no task contributes examples to both splits.

Composition

Peripheral	GPIO	I2C	PWM	SPI	UART
Examples	414	328	227	221	167

Difficulty	Easy	Medium	Hard
Examples	694	488	175

Usage

from datasets import load_dataset

ds = load_dataset("vanty120/edgecoder-rpi5-c-sft-v1")
example = ds["train"][0]

Train only on the final assistant turn: mask the prompt and, for repair examples, the failed first attempt.

def encode(example, tokenizer):
    msgs = example["messages"]
    full = tokenizer.apply_chat_template(msgs, tokenize=False)
    prefix = tokenizer.apply_chat_template(msgs[:-1], tokenize=False)
    ids = tokenizer(full, add_special_tokens=False)["input_ids"]
    n_prefix = len(tokenizer(prefix, add_special_tokens=False)["input_ids"])
    return {"input_ids": ids, "labels": [-100] * n_prefix + ids[n_prefix:]}

For Mistral-family tokenizers (e.g. Ministral 3), load the tokenizer with fix_mistral_regex=True.

Dataset Creation

Curation Rationale

Public code corpora for Raspberry Pi are dominated by libraries and interfaces that no longer work on Raspberry Pi 5, where GPIO is handled by the RP1 chip. The few existing instruction datasets for this hardware either rely on those interfaces or verify only that code compiles. This dataset favours correctness over volume: an example is included only if its code demonstrably behaves as specified.

Source Data

• Topics. Function-level topics were planned from a skill taxonomy, for example the libgpiod v2 request flow, edge events, line information, SMBus block transactions, termios framing, SPI command framing, and sysfs PWM sequencing. Real part numbers seen in prompts of NOKHAB-Lab/LLM_4_HW-SW_Interface (CC BY 4.0) served as topic ideas. Only device names were used, no text or code from that dataset.
• Tasks and solutions. For each topic, muse-spark-1.3-contributor produced:
  • a bilingual task description and a function signature;
  • a reference solution and an alternative solution;
  • a test against a simulated device;
  • 2–4 deliberately incorrect "mutant" solutions.
• Student attempts. The failed first turns in repair examples were produced by Ministral-3-3B-Instruct-2512 (Q4_K_M, temperature 0.7) on the same tasks. Feedback turns are the verifier's actual compiler and test output.

Verification

Each task passed all of the following before any example was derived from it.

1. Compile. gcc 14.2 with -std=gnu11 -Wall -Wextra -fsanitize=undefined. Warnings that indicate real bugs are treated as errors. The code is linked against the task's test.
2. API scan. No sysfs GPIO, wiringPi, pigpio or bcm2835, no /dev/mem or /dev/gpiomem*, no hard-coded gpiochipN, no libgpiod v1, and no GPIO v1 ioctls.
3. Behaviour. The test runs in a network-isolated, unprivileged container against simulated hardware:
   • the gpio-sim kernel module (GPIO);
   • the i2c-stub kernel module (I2C);
   • pseudo-terminals (UART);
   • a fake spidev device (SPI);
   • a fake sysfs PWM tree (PWM).
4. Test strength. Every mutant must be rejected.
5. Test fairness. An independent solution, written from the description alone with the same prompt used at deployment, must also pass. This protects against tests that reject correct code.
6. Stability. All accepted tasks were re-run through the verifier, and none was flaky.

Filtering and Decontamination

• Deduplication. Near-duplicate tasks were removed: MinHash, Jaccard ≥ 0.8 on code and descriptions.
• Prompt hygiene. Prompts that mention the testing setup were removed. Answers longer than 900 tokens were removed, because the target deployment caps output at 1,024 tokens.
• Benchmark decontamination. The project evaluates models on a separate, non-public benchmark of 120 tasks. Training topics close to benchmark topics were rejected at planning time. Tasks whose description or code reaches Jaccard ≥ 0.5 with any benchmark task, or that reuse a benchmark function name, were dropped. The highest similarity of any kept task to the benchmark is 0.42.

Personal and Sensitive Information

The dataset contains no personal data. It was scanned for file-system paths, credentials, e-mail addresses and IP addresses, and none were found.

Considerations for Using the Data

Limitations

• Explicit descriptions. Many descriptions spell out registers, formulas and error codes, so they are more explicit than typical engineer requests. Short paraphrases cover only part of the tasks in v1.
• Device constants. Register maps and conversion formulas are stated in each task. Treat them as the task specification, not as authoritative datasheet values.
• Simulated hardware. Behaviour was verified on simulated devices. Timing is checked at about 10 ms resolution, and baud rates and electrical characteristics are not simulated.
• Easy-skewed. Coverage leans towards easy and medium tasks; hard tasks make up 13% of examples.
• Generated content. All task text and solutions were generated by language models and then filtered by automated verification. Review code before deploying it on real hardware.

Intended Use

Supervised fine-tuning and evaluation of code models for embedded Linux on Raspberry Pi 5, including models that run on the device itself.

Additional Information

Licensing

This dataset is released under CC BY 4.0. When using it, please also credit NOKHAB-Lab/LLM_4_HW-SW_Interface for the device topic ideas.

Terms of the Generator Model

Task text and solutions were generated with the Meta Model API. Its Terms of Service (section 10.1(ix)) restrict using outputs to train, fine-tune or distill models that compete with Meta's models or services. Users are responsible for making sure their use is compatible with those terms.

Version History

• v1 (2026-10): first release, with 386 tasks and 1,357 examples. A larger v2 with more tasks and more short paraphrases is planned.

Citation

@misc{edgecoder_rpi5_c_sft_v1,
  title        = {EdgeCoder RPi5 C SFT v1: Execution-Verified Instruction Data for Raspberry Pi 5 C Programming},
  author       = {vanty120},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/vanty120/edgecoder-rpi5-c-sft-v1}}
}