I am interested in starting a new experience in ARM assembly next year. Totally clueless questions;

1. What hardware do I need? Can I run it on my PC? Do I need an emulator like QEMU because I don't have Android Phones. My current phone is smart enough to have a small flashlight led attached to it. Useful though.
2. Do I need specialized SDK similar to Win Phone/CE SDK?
3. I read that there are too many ARM 'families' out there. Which one should I start with If I were to take the 64-bit path?

I got more questions but I'll ask later.

Ok like for example I want to print a "hello world" to screen. Whose screen because my screen resolution is 1600 x something wide. That screen or emulated screen or real android phones screen?

Anything that is not locked down would be a good start. Many cellphones do not allow you to directly run assembly code so check before you buy. Maybe, if you want to interact with the OS. If you want bare-metal then you'll need more than an SDK, you'll need full system info. That will mostly depend upon the board you buy/have. You won't really be able to buy a CPU of your choice, you have to buy the whole board with CPU/SOC included. Well, that is unless you are planning to make a million or so units then you can buy your own CPU/SOC but that is a whole different thing.

And my PC don't have touch screen either. If I were to run my code in an emulator, don't I need a touch device for that?

This is important because I'm considering to sell my laptop for some android smartphone. But before I do that, I need to test it first, at least in emulated environment. I am not rich you know.

revo, I'm having trouble understanding your explanations, or may be I am too clueless to get it. To cut it short,

What do you personally use to code ARM?
What is your recommendations for a clueless low-budget peasant like me?

I read things on the internet, but still don't get the bigger picture though.

fasmarm, of course. And notepad2 to edit the sources. But then I don't program for phones or any consumer gear. Some other users here have bought second hand equipment (Gameboy? Nintendo?) and written code for them. There are topics with code posted and some info on how to get it all up and running.

But how do you test your source without the CPU?

you could use qemu, https://developer.mozilla.org/en-US/docs/Mozilla/Developer_guide/Virtual_ARM_Linux_environment for a start

i would suggest using router with USB, flash with openwrt or etc firmware, they are less expensive and available in every pc shop or reuse old tp-link is fine too, try tp-link brand, they are the cheapest afaik,

or you could buy raspberry pi 3 and load it with windows 10 iot or linux arm, could explore both experiences

https://developer.microsoft.com/en-us/windows/iot/docs/kitsetuprpi

Setting up Qemu on Linux now... Thanks for the links. Now it's starting to make sense.

Sorry for hijacking this thread instead of starting a new topic.

This is my "Hello, world" Linux program in both ARM 32-bit and x86:


I understand that ARM is a load / store architecture, hence the needs of LDR.

"len" is a constant.

Probably Raspberry Pi, cheap and likely the most well documented, easily hackable with a huge and helpful community.
Also works with qemu on your PC, see qemu-system-aarch64 -M raspi3b
RPi comes with Linux (RaspiOS), so you can use the usual toolchain (on the ARM board), and FASMARM works too out-of-the-box (on your PC as a cross-compiler).
Anything that claims to be ARMv8 and up. But yes, there are quite a lot, but the worst part is, there are even more incompatible SoC platforms (an ARM CPU in itself can't do much, you will need other chips as well, like an interrupt controller, a timer, input/output peripherals, etc. etc. etc. and with ARM this latter part isn't standardized at all. Basically it's as many standards as many vendors. RPi uses the Broadcom SoC, or BCM2711).

Here's a good tutorial, with lots of details, and easy to follow step-by-step explanations: https://github.com/bztsrc/raspi3-tutorial (also includes Makefiles to run the results in qemu).
For FASMARM examples specifically, take a look at https://github.com/PeterLemon/RaspberryPi (not much explanation, just Assembly code. The kernel7.asm is for ARMv7 (32-bit), and kernel8.asm is for ARMv8 (64-bit)).

Although keep in mind, that a simple "Hello world" is quite complicated and platform specific, it's not as easy as on x86 where you just write the characters and color codes at B8000h. What you'll need to do:
1. get the framebuffer address, pitch, packed pixel format (platform specific, on RPi you have to construct a MailBox message to the VideoCore GPU)
2. load somehow a bitmap font
3. render the glyphs yourself pixel by pixel to the framebuffer
As an example, take a look here (although C, but easy to follow, uses Linux's console font) or here (Assembly only, not much comments about the "why", just "how", but still good resource).

Because this is so complex, I suggest to program the UART instead first, and send characters to the serial line, that's several magnitude easier. If you add -serial stdio flag to qemu, then you'll see the the characters on the same terminal window that you have used to start qemu.

But if you're just interested in ARM Assembly, and not low-level ARM Assembly programming, then probably all you need is RaspiOS, and a FASMARM compatible source with format ELF64, and use the svc instruction to invoke Linux system calls. Downside that this probably won't work on qemu, or it's going to be painfully laggy at least.

Hope this helps,
bzt