Raspberry Pi RISC OS System Programming Book

This sounds like interesting news from the author of
“Raspberry Pi Assembly Language Beginners”:

Thought it might be beneficial at this point to mention I am currently working on a my next book in the “Hands On Guide” series, provisionally titled, “Raspberry Pi RISC OS System Programming.” My aim in this title is not to replace the PRMs (they are still an excellence resource), but to provider a wrapper around them for using RISC OS and provide enough information to make it a lot easier to use the PRMs. To a degree – as much as I can research – this will include additional material that has been updated since the PRMs (filing systems for instance). It will also show how to deal with programming issues that have changed significantly the advent of a full 32-bit ARM and CPSR, interfacing etc.
I would be keen to get feedback from forumites about what people would like to see in the book. I would also been keen to include for any new material that users might be able to contribute. No point in doing the research twice!
What does everyone think? If there is interest then perhaps we can start a new “book thread” and I can include an active contents list regarding what is in and out? I am very keen to continue to promote RISC OS for the RPi and am actively trying to support it with a series of publications, so input and help would be greatly appreciated.

http://www.raspberrypi.org/phpBB3/viewtopic.php?f=55&t=32241&start=25

This is a welcome development. I bought a copy of Raspberry Pi Assembly Language. Bruce Smith must have been working hard to produce it in the short time since RISC OS has been available on the Raspberry Pi. It is clearly based on Archimedes Assembly Language. It is well written and nicely laid out, IMHO. It lacks any material on coprocessor or floating point instructions. VFP does not figure in the index. Maybe we can look forward to such material in the proposed new book? Another topic that I would like to see is an expansion of the Program Environment section of PRM Vol 1, with illustrations, and discussion of how shared libraries work.
Bruce Smith is being bold in canvassing for topics to be included. It is easy for people to suggest, much harder for the author to write. I wish him success and applaud the venture, which comes at a critical moment.

Bruce Smith is being bold in canvassing for topics to be included.

Indeed; though I would second a comment already made in that 26 bit modes should be relegated to an appendix. The old PC+PSR stuff has no relevance on anything later than a RiscPC, and that is >15 years old. The current crop of machines that people will be buying for RISC OS use (mostly the RPi due to its price, mind you!) have no support for such things. It may be worth mentioning the older ways, as there is a lot of old code out there that people may stumble across, but it’s 32 bit all the way now.

Additionally, I would like to see some coverage of VFP/Neon/SIMD. This isn’t so much RISC OS as covering newer expansions to the capabilities of typical ARM devices.

I too wish him luck and will wait patiently to see what arrives.

Hi, just noticed this entry from some time ago. The manuscript for this book is pretty well two-thirds finished and I hope to have something ‘out’ by November (hopefully 2013!).

One of the entries talks about covering VFP. Accessing the floating point unit under Rasbian OS is easy using GCC as the assembler supports the extended instruction set, but the GCC incarnation under RISC OS does not seem to support it. Does anyone know if it is supported elsewhere, or whether it is a cross-compiling exercise?

I am including usage in assembler, BASIC and also C. Whilst I have a reasonable knowledge of C I have not used it in a RISC OS environment and would be keen to know more about calling of SWI’s. Is anybody has a C program or two they could throw my way to demo this – for inclusion in the book, I would be very grateful. Would save me a lot of learning time.

It might do. Does your assembler usage include VFP?

Thanks for that pointer Trevor. Had a skim read – there’s a lot there to look at so I will take a bit more time over it. The sample programs for my Raspbian book are all in assembler, and illustrate fundamentals of programming the co-processor in the Raspberry Pi. Some brief details here at entries for Chapters 22 and 23. I will take on board what the posts say though and see what else I can add.

AFAIK the current state of VFP on the Pi is:

• The VFPSupport module is present, so there’s basic support in the OS for creating and managing contexts. But there’s not yet any support code implemented – so if you execute an instruction which requires software support you’ll get a crash. Easiest way to avoid this is to make sure you configure the context/hardware to use “RunFast” mode (set bits 24 & 25 of FPSCR, e.g. by setting those bits in R3 when calling VFPSupport_CreateContext).
• BASIC assembler supports it
• objasm 4 supports it
• There is a patch I submitted to the RISC OS GCC mailing list a while ago that enabled VFP/NEON support in GCC 4.6, but I don’t think that’s made its way into the main development branch yet. So unless you feel like applying the patch and building the compiler yourself, there’s no support in GCC yet.

I am including usage in assembler, BASIC and also C. Whilst I have a reasonable knowledge of C I have not used it in a RISC OS environment and would be keen to know more about calling of SWI’s. Is anybody has a C program or two they could throw my way to demo this – for inclusion in the book, I would be very grateful. Would save me a lot of learning time.

Using SWIs from C is pretty straightforward, although there are a few different ways of doing it. I don’t have any example programs, but I can point you at a few bits of code to use as a reference.

1. Use assembler functions or inline assembler to call the SWIs directly. On the Arc this was the fastest way, but I think it’s generally frowned upon nowadays as it can thrash the data cache a bit and result in worse performance than _swix() (This is down to the way the kernel has to examine the instruction to determine the SWI number. With _swix() and _kernel_swi() there’s only ever one SWI instruction which gets used for all SWIs, but with assembler there’s obviously one per SWI number, or potentially one per SWI call if you use inline assembler)
2. Use _kernel_swi(). This is a bit of a sledgehammer approach as it saves and restores R0-R9 over the SWI call – so not the best for performance. But handy for some SWIs which do things in unusual ways. See here for some simple examples. Note that the ‘X’ version of the SWI is called by default, to call the non-X version you need to OR in the _kernel_NONX flag with the SWI number. There’s also _kernel_swi_c() for SWIs which return a value in the carry flag.
3. Use _swix(). This is a slightly more scary interface but has better performance as it only saves/restores the required registers. The _IN(), _INR(), _OUT() and _OUTR() macros are used to specify which registers are saved/restored, and the input/output values are passed directly to _swix() via variadic args. There’s also _swi() for calling the non-X version of SWIs (required if you want to use _RETURN() to return a value directly instead of returning an error pointer), and _FLAGS for getting the flags returned. See here for a few examples
4. Use something like OSLib, which provides user-friendly C functions and data types for all the main OS SWIs. However see point 1, in that I think OSLib relies on lots of separate SWI instructions – so performance might not be as high as _swix(). There’s a somewhat old version of OSLib in ROOL’s CVS here if you want to see what it’s like (a much newer version is available from riscos.info, I believe).

Jeffrey – thank you for that information, very useful and much appreciated. Thank you for taking the time.
I am not sure if there is a database of all new logged commands and SWI’s in relation to the Raspberry Pi, but if there is I would be interested to know of it!

WIMP World
For my next challenge, I have set about looking at the WIMP for the next section of this book. I had some old BBC BASIC programs from Acorn User and Dabs days so set about try to transform them for the Raspberry Pi and learn a bit in the process. Emm.
I started to trawl through the forum pages and found an informative post here: A WIMP Hello Word.
Effectively this went through all the things I had been trying and including the “Window Manager In Use” message when calling Wimp_Initialise. I really wanted to come up with a BBC BASIC template that folks could use and play with.
So now I am stuck between a rock and a hard place, in that as I understand it now, I simply won’t be able to do that as you can’t run a multitasking program from a task window. Any suggestion?
I have not used software such as Dr Wimp, but is this a more practical alternative for budding programmers to use than trying to claw their way through all the issues that seem to be mentioned in the post above? Are there better alternatives?

as I understand it now, I simply won’t be able to do that as you can’trun a multitasking program from a task window.

That’s right. The reasons are complicated, but if you want to run a multitasking program from a TaskWindow, save it then call Filer_Run. You won’t be able to call Wimp_Initialise.

I have not used software such as Dr Wimp, but is this a more practical alternative for budding programmers to use than trying to claw their way through all the issues that seem to be mentioned in the post above? Are there better alternatives?

I think the benefit of a library is you don’t need to bog yourself down with complications. Want to push text into an icon? Forget memory blocks, dealing with indirected icons and the like… Just call the SetIconText function. Much simpler.

Thanks Rick, seems to me that is very sound advice, and I will go down that route for the purpose of the book. I think this sort of advice is what people are looking for when they are exploring RISC OS at the onset and will avoid the sort of frustrations I was experiencing today (but then isn’t that programming!).
And I’m certainly open to any other suggestions of a similar nature that I can pass on to people looking to find their way towards using the PRMs with a degree of confidence.

I don’t want to confuse things but there are 2 ways of wimp programming the basic method is to use the wimp calls and a template editor the other is to use the toolbox. With the toolbox you can save a lot of programming effort – just combine gadgets/menus/windows together graphically in ResEd and style guide compliance is all taken care of. You can even test the user interface without writing any code. I don’t see the need to introduce someone new to wimp swis or template based libraries – to me its like starting someone with assembler.

Just my 2p.

@Colin
I agree that the Toolbox ought to be the easiest way into programming the Wimp, including progamming in BASIC. The AppBasic libraries do this well and are comprehensively documented. My Basalt module has supported the Toolbox from BASIC for a decade, but there is only a little tutorial support. Nevertheless, it is much faster and more compact, with an event-driven model.
@Bruce
If you wanted to write your BASIC section along these lines, I would be delighted to help.

While the Toolbox is a nice idea for larger programs, isn’t it a bit heavy handed for short and demo programs?

There is obviously an element of preference in choosing one route or the other in may cases it’s down to what you know. I think most people are brought up with the wimp swis so stick with them. Over the years I have used both extensively and find the toolbox simpler from the smallest to the largest program even just using toolbox swis in BASIC. On top of that ResEd is so much nicer to use than any template editor I’ve used and has the added benefit of stopping people putting a slabbed border around text fields – yuck!

Agreed.

With the Toolbox modules already resident a short program can be very short indeed. The shortest Toolbox program I can write, the MinApp example, is 6 lines of BASIC supported by Basalt. It does not actually do anything by it looks impressive. ;-)

I don’t see the need to introduce someone new to wimp swis or template based libraries – to me its like starting someone with assembler.

And, just out of interest, what happens when you want to run some sort of effects or behaviour that is not catered for by the Toolbox? Can you use Wimp SWIs on parts of toolbox windows to do stuff to the icons directly?

And I’m certainly open to any other suggestions of a similar nature that I can pass on to people looking to find their way towards using the PRMs with a degree of confidence.

Ooh, but the PRMs are hardcore nerd. That said, a lot of RISC OS is hardcore nerd. Where else would you get several volumes which is basically “here are all the software interrupts, have fun!” ? Until you are really comfortable with calling SWIs (don’t forget reading flags), you won’t want to get too close to SWIs. But, then, you’ll be missing all the fun stuff.

to me its like starting someone with assembler.

That works too. ;-)
Better to have some idea of what is going on inside, than to learn this year’s trendy high level paradigm…

Bruce should contact Pete Nowosad ( pete_nowosad@msn.com ) if, as I think he should, he is going to say something about VFP in RISC OS on the Raspberry Pi. As far as I know Charm is the only language so far to use it. You can get some idea of what is required by looking at the files fp, vfp, maths in lib.src in the Charm distribution.

While I am at it, let me encourage Bruce to look at RiscLua, whose abstraction facilities make it very easy to hide complicated detail. This is a short wimp program:

local task in (require "wimp.task")
local dim in riscos; local fred = task "Fred"
do -- define fred
  local _ENV = fred -- make fred the global environment
  mask, count, b = 0x1c03932, 0, dim (256)
  local ask = "OK - go on? CANCEL - stop? Count = %d."
  local goodbye = "You reached %d. Goodbye."
  local null_event, flags, OK = 0, 23, 1
  handler[null_event] = \ (self) count += 1
    => self:report (ask:format (count, flags)) ~= OK end
  preclosedown = \ (self) 
    self:report (goodbye:format (count)) end
end -- define fred
fred:init ( ); fred:run ( )

Rick.

And, just out of interest, what happens when you want to run some sort of effects or behaviour that is not catered for by the Toolbox? Can you use Wimp SWIs on parts of toolbox windows to do stuff to the icons directly?

Gadgets are not icons but you can get a list of icons used to implement the gadget so I suppose you can modify that. It’s not something I’ve needed to do. It may be that the toolbox can do what you are thinking it can’t. If you mean by effect changing how normal gadgets look – don’t.

to me its like starting someone with assembler.

That works too. ;-)

Better to have some idea of what is going on inside, than to learn this year’s trendy high level paradigm…

You can’t get a go at the inside Jeffrey Lee’s commandeered it all :-) Keep going Jeffrey we appreciate it. High level paradigms work in assembler too. You knew I’d say that didn’t you :-)

And, just out of interest, what happens when you want to run some sort of effects or behaviour that is not catered for by the Toolbox? Can you use Wimp SWIs on parts of toolbox windows to do stuff to the icons directly?

Generally, you can get at the icon and window handles and do what you need to do. There are some things that are a nightmare, though. Trying to hang a Wimp-based menu off a Toolbox-based menu being the one that springs to mind. Been there, tried that. Ouch.

But I definitely think it would be a shame to write a book about Wimp programming for RISC OS without mentioning the Toolbox. I think it’s great. Also if you’re talking about C, OSLib definitely needs a mention.

Thanks for everyone’s comments, they are very much appreciated. (Apologies for delay in replying – time zones…)

I had originally earmarked three chapters for coverage of WIMP and despite the issues I see no reason to change my mind – I just need to come at it at a different angle and showing the reader the different options available and how best to put them into action.

I am trying to aim the book at the gap between beginner and PRM nerd. I expect the person to understand a bit about programming but not just how to do it on the RPi for example. The idea being to wipe away the frustration a lot of those starting out on RISC OS have. The WIMP as it turns out is both a useful and typical example! This is not for hard core expert but someone who wants to learn.

Your offer of help is gratefully accepted with regards to the Toolbox etc and coming at the why, how and where with some examples would be great. If you want to drop me an email with some thoughts that would be great. (email@brucesmith.info). The MinApp example sounds good.

Thanks I will get onto that, and I will probably include details on RiscLua etc as a way of broadening horizons

I will include coverage of Dr Wimp in both BASIC and C flavours as I think it is a great example of what you can do with BASIC and RISC OS. I can’t believe the amount of work that has gone into the project and how easy it was to use. It may not be the most elegant solution but it does what it sez on the tin. I also have a chapter about using Assembler, BASIC and C with RISC OS and swi calls form all – so OSLib gets coverage.

I love assembler, but also think its important to show users how the basics all come together. And one of the chapters will be about describing some of the more important SWIs and the order process and reason for making everything happen, and appreciate the sophistication of the the application they are utilizing.

Thanks very much for the comments which I greatly appreciate and hopefully I can include all the above in the chapters about WIMP. I do think its important to show what is available and provide a balanced view so that the reader can investigate further and make up their own mind. Diversity is what we need!

Just in case it got lost in the flurry of responses up above, and so that Steve isn’t seen to be blowing his own trumpet ;), I’ll just throw Basalt out there again. It has great support for the Toolbox, and deserves a mention next to !AppBasic and other Toolbox-related libraries, etc.

Noted. Everything will get a mention promise you – and if anyone has copy or examples of use they can send me I will look to include them as well.

Interrupt Examples
Am on the lookout for a good demo program using interrupts/events if anyone has one?
As an idea I was thinking of something to play a named mp3 file or something similar? But open to offers.
Thanks.