Cart

Your cart is empty

FAQ

This page contains basic information to help you understand the philosophy of rosco_m68k and avoid common beginner mistakes.

Who is this computer for?

rosco_m68k is primarily aimed at people who want to understand how a computer works at a low level. It is a platform for those interested in computer architecture, the boot process, memory, interrupts, and for anyone who wants to write low-level code such as bootloaders, drivers, their own operating systems, or system utilities.

It is also suitable for retro-computing enthusiasts and for anyone who wants to work with hardware without modern abstraction layers.

How is ROSCO different from Raspberry Pi and Arduino?

rosco_m68k is an open project of a classic computer based on the Motorola 68010. It exposes a real address and data bus, separate memory, controllers, interrupts, and a full boot process. You interact with the system in much the same way engineers did with computers in the 1980s and 1990s. It is an educational and exploratory tool for understanding how computers really work.

Arduino is a microcontroller. It is a single chip with RAM, flash, and peripherals already built in. You simply compile and run code in an infinite loop. Memory, buses, and most hardware details are abstracted away. Arduino is ideal for sensors, automation, and prototyping, but it does not teach computer architecture.

Raspberry Pi is a single-board computer with an ARM SoC, GPU, USB, networking, and a ready-to-use operating system (usually Linux). You boot from an SD card and immediately have drivers, a filesystem, and a user space. This is convenient for servers, media centers, or application-level projects, but most of the hardware is hidden behind many abstraction layers. Even GPIO access goes through several layers.

The key difference is this:
ROSCO is a computer in the classical sense, with a minimal bootloader and maximum transparency.
Arduino is a microcontroller, not a computer.
Raspberry Pi is a modern computer where almost everything is provided out of the box.

What can ROSCO NOT do and will never do?

ROSCO is not, and does not try to be, a universal computer or a replacement for popular development boards. Some limitations are fundamental by design.

  1. rosco_m68k is not plug-and-play. The board is not an all-in-one solution, and the user is expected to understand what they are building. That said, if assembled correctly, the system usually boots on the first try.
  2. rosco_m68k does not have a large ecosystem of ready-made libraries, frameworks, or tutorials. The main sources of knowledge are the official documentation, chip datasheets, and hands-on experimentation. This is a conscious trade-off.
  3. rosco_m68k is not intended for modern application-level tasks such as web, multimedia, AI, or a desktop-like experience.

It is a tool for learning, experimentation, and low-level hacking—not a turnkey solution.

I’ve assembled ROSCO. What should I do next?

The most logical next step is to run the test programs and verify that the system is stable. This allows you to check memory, UART, timers, and the basic logic of the board. A detailed guide is available in the documentation.

After that, the only real limitation is your imagination.

I’ve connected everything, but the system does not start. What should I check?

Start with the LEDs. A successful boot looks like this:

If the UART LEDs blink but there is no output in the terminal, check:

  • correct RX/TX wiring,
  • the baud rate (it must be 38400).

If the RUN or RESET LEDs are not lit:

  • check the power supply (voltage and polarity),
  • check chip orientation,
  • make sure there are no short circuits.

If the problem persists, contact us—our details are available here.

What languages can be used to write code for rosco_m68k?

Any language that can be compiled into machine code for the m68k architecture can be used. In practice, assembly (vasm) and C are the most common choices.

Assembly gives full control over the system with no limitations, but requires more effort. Writing C code is simpler, but comes with constraints related to the runtime environment and standard library.

Can I run C code?

Yes. rosco_m68k provides its own bare-metal C runtime and a set of standard libraries designed specifically to work without an operating system. These libraries offer basic functionality such as printf, UART I/O, SD card support, a heap allocator, and other utilities.

Important points to understand:

  • this is a freestanding C environment, not POSIX and not glibc;
  • the standard library is minimal and adapted for bare-metal use;
  • dynamic memory (heap) is implemented via a simple allocator and has limitations;
  • the program entry point is kmain, not the traditional main;
  • basic initialization (stack, .bss, .data) is handled by startup code, but further control over interrupts, memory map, and system logic is the developer’s responsibility.

ROSCO provides a convenient starting point for C code, while still exposing the system’s low-level nature.

What does a typical program workflow look like?

In simplified form, the process is:
compile → transfer the binary (via Kermit or SD card) → the bootloader immediately starts the program.

How do I load a program onto rosco_m68k?

There are two main options:

  • via SD card,
  • via UART using Kermit.

Both methods are described in the documentation.

Are there ready-made example programs?

Yes. The documentation includes examples and video guides.
Note: when running from an SD card, the file must be named ROSCODE1.bin, and the SD card must be formatted as FAT32. Otherwise, the program will not start.

Can I write my own mini OS?

Yes. rosco_m68k does not prevent this.
However, without prior experience in low-level and systems programming, it will be difficult. At the same time, it is an excellent learning project. The key is not to abandon it halfway through.

Is there an emulator?

Yes. An emulator is available that allows you to run and test code on your main PC without physical rosco_m68k hardware. This greatly simplifies debugging.

Where should I start if I’m new to low-level programming?

Start with the basics:

  • learn the m68k architecture,
  • read the rosco_m68k documentation and the datasheets for the main chips,
  • run the provided examples,
  • study simple assembly code, even if you plan to write C.

What simple projects should I try first?

Beginner level:

  1. Hello World (C and ASM) — compilation, loading, execution.
  2. Hex dump — a utility that reads and displays memory.

Intermediate level:
3. Timer and delay without busy-looping — using interrupts.
4. A simple memory monitor over UART.

Advanced level:
5. A primitive scheduler.
6. File access on an SD card.
7. Your own bootloader or mini-kernel.

Can I run Linux?

In theory, yes. In practice, with major limitations. The lack of an MMU and limited CPU resources make it possible to run only uClinux or similar systems. This is more of an experiment than a practical solution. The uClinux repository and guide are available in the documentation.

Can I connect Ethernet or Wi-Fi?

Yes, but with limitations. You need external controllers, custom or adapted drivers, and must account for limited bandwidth and system resources. rosco_m68k is not designed for networking tasks, but it does not prevent experimentation.