Suggestions for microprocessor module

[Analog Kid]

I ask this question here with much trepidation, as I just know this thread will probably blow up all kinds of ways, with people thinking they're being helpful when they're not. But here goes:

I'm looking for a microprocessor module, and excuse me if I'm not using the right term there:
What I'm pretty sure I want is a micro that I can program from my PC on a board with memory, etc., not just the chip.

Here are my requirements--please pay attention to them, as some of them are not negotiable (others may be):

• I'll need at least 16 I/O ports/pins; more would be OK
• My memory requirements (RAM, EEPROM, etc.) are minimal: probably 4K would be enough for my program space (more would be OK, of course)
• No A/D converter needed, although that would be nice for future use
• Must be USB programmable from my PC

And importantly:

I want to program this in assembly language. Not C, C++, C#, Python, etc. Just straight native assembly languge.

No Linux stuff at all. Want to use it with Windows 7.

Ideally it would come with all the software I need to program and run it; debugging would be nice too.
I don't want to have to hunt all over hell and gone to gather up the needed libraries, COM stuff, VC, any of that crap.
Just an assembler + linker, some kind of IDE to let me program it and run my programs (maybe even debug them).

I've looked around online: there are just too many choices out there for me to evaluate them.
That's why I'm posting this here to pick the brains of people who have used this stuff, know the selection and might be able to help me at least narrow down my choices.

Obviously I'm not looking for anything high-end. Performance is not an issue here.

Just to give you some idea, the last chip I played around with was the SX-28, then from Ubicom, now (I think) Microchip. But I no longer have a programmer for it. I was able to program in assembler and it worked fine for me. Something like that, if available, would be just fine and dandy.

Thanks in advance for any helpful replies.

[brucehoult]

This is my go-to board that meets your specs. Click on the option with WCHLinkE programmer and/or USB cable if you don't have those.
https://www.aliexpress.com/item/1005005221751705.html

You can write in C or asm as you prefer.

You will need to have some female to female Dupont wires. And I solder three pins on to the GND, D10, 3V3 row for power and flashing and debugging.

The CH32V003 version has been around the longest and has 16k of flash and 2k RAM. The CH32V002 and CH32V004 versions are the same price and have a multiply instruction, better ADC, wider voltage range. The 002 has 4k RAM, the 004 has 32k flash and 6k RAM.


Use them with https://github.com/cnlohr/ch32fun

Getting started instructions for common OSes here:

https://github.com/cnlohr/ch32fun/wiki/Installation

You can use UART debugging or ch32fun includes a utility called minichlink. It acts as an ultra-fast GDB server. By spinning up minichlink -G, you can direct VS Code's (or other) GDB instance to target localhost:3333 to flash and debug the chip.

There is also the manufacturer's Mounriver IDE and HAL if you prefer, but I would say most people don't prefer.

When you clone ch32fun, you don't even need a complex VS Code (or other IDE) configuration if you just want to use the terminal.

The repository includes automated make targets.Once your NanoCH32V003 is wired to the WCH-LinkE:

- Open your terminal in an example folder (like examples/blink).

- Run make to compile.

- Run make flash to program the chip via minichlink.

- Run make debug.

The make debug command automatically boots minichlink in GDB-server mode (-G) on port 3333 and launches riscv-none-elf-gdb, instantly giving you a terminal-based breakpoint debugging interface.

Windows is supported as well as Linux and Mac.

Command-line use should be fine on Windows7. Internet says you need to use the "Zadig" free utility to replace the standard Windows 7 WinUSB driver with a better driver.

You also need a compiler/assembler/linker.

https://github.com/xpack-dev-tools/riscv-none-elf-gcc-xpack/releases

The instructions say even the newest version works with Windows 7 with the Universal C Runtime (UCRT), whatever that is.


You can also use the Arduino IDE if you prefer. You need the "Legacy" 1.8.19 version. Just paste into the "Additional Board Managers" field in Preferences:

https://github.com/openwch/board_manager_files/raw/main/package_ch32v_index.json

Then in Tools / Board / Boards Manager select CH32V00x and WCH-Link as the programmer.

That's possibly the easiest of all, but supports only printf() debugging not GDB.

[Analog Kid]

This is my go-to board that meets your specs. Click on the option with WCHLinkE programmer and/or USB cable if you don't have those.
https://www.aliexpress.com/item/1005005221751705.html

Thanks a lot! Still digesting your reply.

Unfortunately that item comes up "Sorry, this item's currently unavailable in your location." Do you have another link, or maybe just a part ID?

[brucehoult]

Oh! What backwards part of the world are you currently located in?

That's the $1.50 each Muselab nanoCH32V003. They make good quality inexpensive boards for a number of microcontrollers and FPGAs.

Here's the same thing from what appears to be a different manufacturer on Amazon .. but it's so simple it's hard to get wrong!

https://www.amazon.com/MusRock-CH32V003F4P6-RISC-V-Development-Projects/dp/B0FXWXC9M3

Easy to solder wires to, solder headers to on either the top or the bottom (to plug into a 0.1" breadboard).

You'll need to separately add a programmer/debugger. e.g.

https://www.amazon.com/WCH-Linke-Debugger-Downloader-Interface-Support/dp/B0C6XRCS9Q

I don't know why that's so expensive. From China they're $2 or so.

NOTE WELL ... for the CH32V003/2/4/6 you the LinkE not the older Link. Some Described as WCH-Link might actually be LinkE, especially if offered bundled with 003 boards, but it's better to be sure.


Another popular and good alternative is of course the RP2040 chip. It's a bit more powerful but also a bit more complex to program, especially in assembly language.

https://www.amazon.com/hiBCTR-RP2040-Zero-Board-Dual-Core-Cortex/dp/B0FND59TMH/

They do have the advantage of built in USB so you don't need a separate programmer board.

Both have large and active communities around them.

At the bare chip level it's something like $0.10-$0.20 vs $1.00 but this largely disappears with a complete dev board.

Here are some things people have done with CH32V003:





That latter is a €1.00 kit from Olimex in Bulgaria:

https://www.mouser.com/en/ProductDetail/Olimex-Ltd/RVPC?qs=wT7LY0lnAe25CQLWq3FKIw%3D%3D

[dobsonr741]

I suggest STC89C52RC. Good old 8051, bootloader built in. Lots of books on 8051 assembler.

https://a.co/d/05LxtRDD

[Renate]

Oh, well, let the mudfest begin.

For me, those two suggestions are right out.

There's certainly a dividing path between RISC and ARM at the assembly level.
You can go either way, but go with your eyes open.

Going down 8008/8080 except as retro is a headshaker for me.

If you're going for a deep dive into a system pick one that will help you in your future designs.

Me, I'd go for ARM.
A Seeed Xiao SAMD21 is nice and small but doesn't do your 16 I/Os.
An STM32F103 ("Blue Pill") would do what you need, but you might as well use an STM32F411 ("Black Pill").

If you're entirely "rolling your own" you're going to learn about loader files (.ld) and clock chains.

[mariush]

The Microchip SNAP is 10-12$ and can be used in Windows 7

https://www.microchip.com/en-us/development-tool/pg164100

buy from

https://www.microchipdirect.com/dev-tools/PG164100

https://www.tme.eu/en/details/mplab-snap/programmers/microchip-technology/pg164100/

https://eu.mouser.com/en/ProductDetail/Microchip-Technology/PG164100?qs=w%252Fv1CP2dgqoaLDDBjfzhMQ%253D%253D

https://uk.farnell.com/microchip/pg164100/in-circuit-debugger-1-2v-to-5/dp/2915518


you can still program loads of 8 bitters in asm but plain c and mplab-x is decent, and you  can inspect generated asm code

note programmer also supports a bunch of atmel parts now that microchip aquired them .. different architecture than PICs

[brucehoult]

There's certainly a dividing path between RISC and ARM at the assembly level.
You can go either way, but go with your eyes open.

They're virtually identical.

The smallest Arm (Cortex-M0) have only 2-address instructions (except for add), and a random selection of what literal/offset sizes each instruction takes. M3 and M4 are much better. Arm has register+register addressing, RISC-V makes you do the add yourself first. Of course both do register+constant addressing.

RISC-V always has full, consistent, instructions: every instruction that takes a constant or offset takes a 12 bit one. The tiniest CH32V00x RISC-V have 16 registers, as do all 32 bit Arm. The CH32V1xx, 2xx, 3xx have 32 registers.

WCH and STM peripherals are identical to program. Same registers, same fields, same constants.

8008 / 8080 / 8051 / PIC indeed are from a different time and should be forgotten. The only 8 bit I'd consider is AVR.

But OP asked for a concrete and easy solution, not a thousand possibilities. The CH32V003 I suggested has become very popular since it came out 4 years ago.

Our host even made a video way back four months after they came out:

[tycz]

Analog Kid,

I used to program Microchip PIC microcontrollers in assembly before I learned C. I started on PIC16F84, then went to the PIC16F628A, then finally the PIC16F1947. I did this for about ten years and found it found it quite enjoyable. After that I learned C and didn't program in assembly any more.

I'd suggest looking at the 8 bit PIC range. Apparently, the SX-28 is like a very fast PIC, so you would already be familiar with the assembly language. I used to use MPLAB IDE (not MPLABX) and a Pickit device (version 2, I think) for writing the code and debugging. It came complete with assembly headers for all the parts, no additional software necessary.

Dobsonr741 mentions STC 8051 microcontrollers. These might be a good choice because they don't need any special programming hardware, just a USB to TTL serial adapter. The STC 8051 parts have code examples for all peripherals in both C and assembly right in the datasheet. On chip debugging requires Keil Uvision, which is very expensive now, so you generally can't do this for a reasonable price on STC micros.

I wouldn't take the suggestions from Brucehoult too seriously. Nobody is programming CH32V003 or RP2040 in assembly language. You are on your own there.

[Renate]

They're virtually identical.

From a bird's eye view they're all Turing machines too.

I think that they are all so cheap these days that it's not useful to use the $2.50 vs $0.10 to affect your decision if your time is worth anything at all.

Programmers (i.e. burners) are cheap enough now and a worthwhile investment.
It's silly to be dead-in-the-water because you broke some silly drag n' drop bootloader.
The wish to use "just the device" (without a programmer) is a bit limiting.

Now avoiding a manufacturer's IDE/infrastructure/HAL is a separate issue.
There are many who develop with just Notepad++, a compiler and a programmer.

[brucehoult]

I wouldn't take the suggestions from Brucehoult too seriously. Nobody is programming CH32V003 or RP2040 in assembly language. You are on your own there.

Well, I am, for one. When I feel like it. And I'm happy to give examples or help.

Most people are programming in C because the C compilers for Arm and RISC-V are excellent and really hard for a human to beat. Unlike on PIC, 8051, 6502, Z80 etc where C totally sucks.

That doesn't make them any harder to program in assembly language than an 8 bit CPU. On the contrary, they are easier because the instructions are so much more powerful and general. Anything that makes life easier for a compiler makes life easier for a human too.

Dealing with peripherals is identical whether you use C or ASM, given an include file with appropriate constants for addresses and fields etc (or not if you want to raw dog the numbers).

No one needs those 1970s 8 bit CPUs today (1980 for the 8051). Yes, I appreciate you've been using them for 40 years. So have I. But there is NO WAY I want to sue them today, and telling beginners to use them is practically abuse. AVR at an absolute minimum, please! And it too has a good C compiler. Because it is a non brain-dead CPU.

[brucehoult]

They're virtually identical.

From a bird's eye view they're all Turing machines too.

That's completely disingenuous.

I can translate between ARM (32 bit or 64 bit) and RISC-V code almost 1 instruction to 1 instruction. From time to time one instruction in one (e.g. compare-and-branch on RISC-V, or load with register-plus-register addressing on Arm) will become 2 or 3 instructions on the other. Not often.

Translate either to brainfuck or 6502 or 8051 or 8 bit PIC and one instruction turns into up to dozens.

I think that they are all so cheap these days that it's not useful to use the $2.50 vs $0.10 to affect your decision if your time is worth anything at all.

It's not a question of price, but of complexity, which translates into your time. Cheaper lower end chips have less complexity, especially in the clocks and peripherals.

Simple peripherals is a win for the old 8 bit chips, but that doesn't make up for the awful instruction sets if you want to do anything more complex than read a byte from peripheral A and write it to peripheral B.

[dobsonr741]

Let op decide which ASM he likes better:

Code: [Select]

; 8051
; LED on P1.0

loop:
    CPL  P1.0          ; toggle GPIO bit

    MOV  R7,#255
d1: MOV  R6,#255
d2: DJNZ R6,d2
    DJNZ R7,d1

    SJMP loop

Code: [Select]

; ARM Cortex-M / Thumb-2
; Assume GPIO_ODR = 0x48000014
; LED bit = bit 0

    LDR   r0, =0x48000014
    MOVS  r1, #1

loop:
    LDR   r2, [r0]
    EORS  r2, r1
    STR   r2, [r0]

    LDR   r3, =500000
delay:
    SUBS  r3, r3, #1
    BNE   delay

    B     loop

Code: [Select]

# RISC-V RV32I
# Assume GPIO_OUT = 0x40001000
# LED bit = bit 0

    li    t0, 0x40001000
    li    t1, 1

loop:
    lw    t2, 0(t0)
    xor   t2, t2, t1
    sw    t2, 0(t0)

    li    t3, 500000
delay:
    addi  t3, t3, -1
    bnez  t3, delay

    j     loop

Code: [Select]

; AVR
; LED on PB0

    sbi  DDRB, 0        ; PB0 = output

loop:
    sbi  PINB, 0        ; writing 1 to PINB toggles PORTB bit 0

    ldi  r18, 255
d1:
    ldi  r19, 255
d2:
    dec  r19
    brne d2
    dec  r18
    brne d1

    rjmp loop

[tycz]

No one needs those 1970s 8 bit CPUs today (1980 for the 8051). Yes, I appreciate you've been using them for 40 years. So have I. But there is NO WAY I want to sue them today, and telling beginners to use them is practically abuse. AVR at an absolute minimum, please! And it too has a good C compiler. Because it is a non brain-dead CPU.

Now that you mention it, AVR seems to fit well with the OP's requirements. Relatively modern instruction set (if that is important) and the peripherals are not as complicated as those on the 32 bit ARM and RISC-V parts. There's a free IDE that supports assembly out of the box with debugging support. No shortage of 'modules' thanks to the Arduino project.

[dobsonr741]

Now that you mention it, AVR seems to fit well with the OP's requirements.

I've added AVR to the ASM samples. As you see, not prettier than any other RISC - as AVR is a RISC. For simplicity sake, 8051 is my choice. Plus the retro glow - no wonder why tube amps are still being built.

[brucehoult]

Let op decide which ASM he likes better:

It's a rather small program to make any decisions from, but it does nicely illustrate my statement that Arm and RISC-V are very similar. Every (pseudo-)instruction in your program maps 1:1 between them.

The `li t3, 500000` will generate two instructions on RISC-V, while on Arm the `LDR   r3, =500000` will generate one PC-relative load there plus a 4-byte constant somewhere nearby, almost certainly just after the `B loop`.

Both benefit from not having to do nested loops just to count to 500000.

In fact the 8051 version only loops 65025, which is only 13% as long assuming similar clock speeds (and plenty of 8051s these days can do 48 MHz with 1 cycle per instruction).

So, actually, to be equivalent, the 8051 code needs to be more like:

Code: [Select]

    MOV  R7,#50
d1: MOV  R6,#100
d2: MOV  R5,#100
d3: DJNZ R5,d3
    DJNZ R6,d2
    DJNZ R7,d1

Also RV32I has an `xori` instruction while Cortex-M0 doesn't have an `eor` with an immediate operand (Cortex-M3/4/7 do). So that can be simplified to:

Code: [Select]

    li    t0, 0x40001000

loop:
    lw    t2, 0(t0)
    xori  t2, t2, 1
    sw    t2, 0(t0)
    :

With those two changes it has gone from 8051 6 lines of executable code and Arm and RISC-V both 8 lines to RISC-V 7 lines of executable code and 8051 and Arm both 8.

But really you need to look at much larger example programs, and programs dealing with something more than peripherals or variables at absolute addresses. Introduce structs, arrays, pointers, pointers to numbers or structs or functions, arithmetic on 16 or 32 bit values .... any of those make things much more complex on 8051 (or 6502 or z80) while Arm and RISC-V take them in their stride.

[Renate]

French and Spanish are isomorphic so it's pointless to decide which one you should learn.
Use a coin.

[Analog Kid]

OK, one thing at a time here:

Responding to @brucehoult, if I want to take your suggested parts, let me review so I've got it straight. I'll need

• A CH32V003 dev board
• A WCH-Linke programmer
• The software package you linked from GitHub, including the assembler, linker and loader

Is that correct?
Anything else?

How do I connect the programmer to the dev board: like pin to like pin?
(I'm sure I could figure it out, just trying to nail things down beforehand.)

And hopefully that software would just run without me having to hunt down additional parts/pieces. I have some version of the Visual C runtimes already installed on my computah.

[brucehoult]

OK, one thing at a time here:

Responding to @brucehoult, if I want to take your suggested parts, let me review so I've got it straight. I'll need

• A CH32V003 dev board
• A WCH-Linke programmer
• The software package you linked from GitHub, including the assembler, linker and loader

Is that correct?
Anything else?

Two software packages:

• a generic RISC-V "embedded" compiler/assembler/linker toolchain. "Embedded" because it uses the smaller Newlib / Newlib-nano not glibc, and statically links all libraries into the program. That's the XPack I already gave a link to.
• header files for WCH microcontrollers, containing information about peripherals etc. This is included with CH32Fun or the MounRiver Studio IDE, whichever you decide to use. A modern IDE is going to give trouble on Win 7, you're better to stick to terminal apps

How do I connect the programmer to the dev board: like pin to like pin?
(I'm sure I could figure it out, just trying to nail things down beforehand.)

GND to GND, 3V3 to 3V3 (3.3V Vcc), SWDIO to DIO (aka PD1) the pin between GND and 3V3 on the 3 pin debug/programming header location.

And hopefully that software would just run without me having to hunt down additional parts/pieces. I have some version of the Visual C runtimes already installed on my computah.

That's all the RISC-V stuff.

As I mentioned, you also need Win 7 updated with a driver that does USB COM ports. That part would be true for any of the other USB-connected microcontrollers too.

Feel free to use one of the many 1970s 8 bit ISAs others have suggested. It won't upset me in any way. I just can't see the point. I did a lot of things with ATTiny85 and ATMega328 AVR chips (which are at least from the late 90s for the ISA, late 2000s for those specific chips) before the CH32V003 came out. They're pretty good. But the WCH stuff is much cheaper, much faster, and an 8 pin CH32V003 can replace an ATTiny85 and a 20 pin CH32V003 can in most cases replace an ATMega328.

And study the instruction set. I've some time ago extracted just the RV32I pages from the full RISC-V ISA manual. 18 page PDF here ...

https://hoult.org/rv32i.pdf

The CH32V003 uses RV32EC, which is the same as RV32I except:

• "E": registers 16-31 don't exist, making it more size-competitive with 32 bit Arm. Assembly language programmers need to know this, C programmers don't.
• "C": the most common forms of some instructions have a 2-byte encoding instead of the standard 4-byte encoding e.g. arithmetic where the result register is the same as one of the source registers, or adding a small constant (-32..+31) to a register, etc. You don't have to know about this, the assembler does it automatically when it can, unless you tell it not to.

If you're into making your own boards, you can get 50 of the 8 pin package for $7.32 or 50 of the 16 pin package for $9.76 or 50 of the 20 pin package for $15.56

https://www.aliexpress.com/item/1005005036714708.html

Lifetime supply for the price of a Big Mac meal.

[Doctorandus_P]

Oh! What backwards part of the world are you currently located in?

Indeed / Disclaimer: IMHO, Doing asm only is mostly a sign of some sort of mental self-harm condition. Maybe you should contact the TEA group.

I used the old Atmels' (Atmega8 and such) for a bunch of projects, and I also studied the asm listings and they were quite readable. The large set of 32 registers also give you plenty of room for storing local variables, which makes AMS much more readable. And these processors are relatively simple and straightforward. Everything works on a single clock domain, no complications with cashing or other surprises. I once also tried ASM on PIC (16F84), and that drove me away very quickly. (4 level hardware stack, bank swithing, horrible convoluted and limited instruction set. yucky).

Do you object to having a C compiler (installed?) at all, or do you just don't want to use it? I don't know how many uC's still have free standing assemblers these days, but many (C / C++) compilers can assemble and link assembly sourcecode.

I also liked the computer introduction lessons at school, which (still) used the 8080 (8085?) Z80 is the same (apart from the extra's) but I liked it's ASM syntax better. Is going full retro an option for you? There are many communities around retro computing, and complete boards can be bought. But prices are going to be higher than a fully integrated microcontroller which has everything in an EUR 2 chip.

[Analog Kid]

Oh! What backwards part of the world are you currently located in?

Indeed / Disclaimer: IMHO, Doing asm only is mostly a sign of some sort of mental self-harm condition. Maybe you should contact the TEA group.

I. Don't. Like. Using. C.
I prefer assembly language.

Unnecessary and uncalled for abuse removed by moderator.

[brucehoult]

Oh! What backwards part of the world are you currently located in?

Indeed / Disclaimer: IMHO, Doing asm only is mostly a sign of some sort of mental self-harm condition. Maybe you should contact the TEA group.

That was with regard to being told "Sorry, this item's currently unavailable in your location." on aliexpress.

I see nothing wrong with learning asm, learning programming using asm, or using asm for projects. If done in moderation. I do it myself, sometimes recreationally, sometimes for profit when compilers don't quite "get it" or you have constraints or desires that fall outside the approved ABI.

I used the old Atmels' (Atmega8 and such) for a bunch of projects, and I also studied the asm listings and they were quite readable. The large set of 32 registers also give you plenty of room for storing local variables, which makes AMS much more readable. And these processors are relatively simple and straightforward. Everything works on a single clock domain, no complications with cashing or other surprises. I once also tried ASM on PIC (16F84), and that drove me away very quickly. (4 level hardware stack, bank swithing, horrible convoluted and limited instruction set. yucky).

AVR is definitely my next choice after RISC-V and Arm.

Do you object to having a C compiler (installed?) at all, or do you just don't want to use it? I don't know how many uC's still have free standing assemblers these days, but many (C / C++) compilers can assemble and link assembly sourcecode.

Any CPU that is supported by GCC has both the following true:

• if you give gcc a file ending in .c then it compiles it, a file ending in .s gets assembled, a file ending in .S gets preprocessed the same as C would be (#include, #define, #if etc) and then assembled
• you can always install just binutils iif you're really allergic to gcc and want to call as and ld yourself, get your library paths right yourself etc

[wilfred]

Oh! What backwards part of the world are you currently located in?

Indeed / Disclaimer: IMHO, Doing asm only is mostly a sign of some sort of mental self-harm condition. Maybe you should contact the TEA group.

I. Don't. Like. Using. C.
I prefer assembly language.

If you don't like that you can kindly fuck off.

I was thinking two things when this thread started. Firstly there are places for Assembly code and it is useful to understand if only to help with diagnosing a tricky issue from the compiler code listing. But it is something from a bygone era when processing power and memory size were constraints. Now you would get a bigger boat chip and move on.

And secondly I thought "don't be judgemental and comment on why would you want to". I'm glad I didn't because I could see the response from miles away.

For the general audience reading this my advice for learning microcontrollers from a POV of little or no prior experience would be find a community that is rich in helpful people and available libraries and go that way. Arduino is one obvious choice but there is a great course online on Youtube by channel Quantum Leaps called "Modern Embedded Systems Programming Course " https://www.youtube.com/playlist?list=PLPW8O6W-1chwyTzI3BHwBLbGQoPFxPAPM
And it uses the TI Tiva C Launchpad. https://www.ti.com/tool/EK-TM4C123GXL

I'd start with that and even if you only use it for the course it'd be worthwhile getting one for under US$20

[Tation]

Any ST Nucleo Board fits here, and they come with on board STLink interface. All needed is a USB cable and software.

Select any with an Arm Cortex-M0/+ core, just not to be overwhelmed by the size of the manuals...

[Analog Kid]

At this point I'm leaning towards Bruce Hoult's suggestions, and I'll tell you why:

Regardless of whether they are actually the do-all and end-all of μprocessors out there, he gave me a complete shopping list, including links to online sales. Not a vague "use an Arduino" or "such-and-such a line of processors is easy to use, blah blah blah". Presumably I could buy what he indicated and be in up and running in short order.

Otherwise I'd have to do a lot of investigation online that I'd rather not do. It's actually quite a luxury now that I think about it, having someone do the homework for me, and I do appreciate that.

Again, I could just go online and swim in the vast sea of choices out there. The reason I ask questions here is because folks here have specific knowledge that can be helpful.

I haven't made up my mind yet, but the items Bruce suggested are cheap enough and would no doubt work for me.

I'm still open to suggestions, but it would be nice if they were specific enough so I don't have to do days of research in order to find all the parts-pieces I need.

And yes, I definitely plan on using assembly language, so please don't try talking me out of that, 'k?