Propeller and Linux, PASM
homosapien
Posts: 147
Have switched most of my computers to Linux Mint, and have been using SimpleIDE to program in C on the prop.
I have an upcoming project that will require close-tolerance timing of outputs, which I would usually turn to a mix of SPIN and PASM for, but have lost that ability with the latest version of SimpleIDE, which as far as I can see only allows C.
I have poked around a bit looking for information, much seems old and changing over time. I see an old thread (http://forums.parallax.com/discussion/161455/tool-for-spin-on-linux) which details using OpenSpin and pi-propeller-load. Is this still the way to use SPIN from Linux ?
Or maybe a better way is to use PASM with C. Any instructions on how to do that within the SimpleIDE? How does one do In-line vs COG ? Is there any difference?
Also, I have kind of been ignoring the different memory models used when making a C program - any links to current documentation on how the different models work (LMM, CMM,COG etc) and what the heck is the fcashe and how does it come into play?
Sorry for what may seem to be a bucket of confused questions, love the prop and the 8 cores, no so much the development arena if not coming from Windows...
Nate
I have an upcoming project that will require close-tolerance timing of outputs, which I would usually turn to a mix of SPIN and PASM for, but have lost that ability with the latest version of SimpleIDE, which as far as I can see only allows C.
I have poked around a bit looking for information, much seems old and changing over time. I see an old thread (http://forums.parallax.com/discussion/161455/tool-for-spin-on-linux) which details using OpenSpin and pi-propeller-load. Is this still the way to use SPIN from Linux ?
Or maybe a better way is to use PASM with C. Any instructions on how to do that within the SimpleIDE? How does one do In-line vs COG ? Is there any difference?
Also, I have kind of been ignoring the different memory models used when making a C program - any links to current documentation on how the different models work (LMM, CMM,COG etc) and what the heck is the fcashe and how does it come into play?
Sorry for what may seem to be a bucket of confused questions, love the prop and the 8 cores, no so much the development arena if not coming from Windows...
Nate
Comments
Finally someone speaks my language
I only jest. We have lots of other Linux users here, they're simply not the ones that usually ask the questions (they're the ones answering them).
You do certainly have some options for Propeller and Linux. For one, you may well enjoy PropellerIDE which is a Parallax-supported (ish), cross-platform, Spin + Basic development environment. BST as Frank suggests is another good (but much older) solution that looks almost exactly like The Propeller Tool. There's also OpenSpin if you just prefer to compile your Spin files from the command-line. But I won't go into any further details on the Spin/Basic/Forth/etc world, because that's foreign domain for me.
I live in the C++ world of the Propeller and (on Linux) it is a very joyous (and lonely) one. In the hopes of making it less lonely, I created PropWare. PropWare gives you a build system to help you compile your code and run it on your Propeller, using the CMake build system. Along with the build system you also get easy access to a suite of libraries: Simple, libpropeller, libArduino, PropWare's own namespace, and (as of quite recently) an efficient JSON library as well. It's all documented on PropWare's website and in relatively active development, so please let me know what you needs the most work and I'll focus my attention there. That being said, it's also getting to be reasonably mature, with some of the objects like SPI and the SD card/FAT filesystem reaching 4 years old.
Even if you don't end up using PropWare's libraries or its build system (you can use either one without the other btw), you will certainly find LOTS of helpful code snippets in it and its dependent libraries. Inline assembly, cogc, fcache and others are demonstrated in various ways.
Speaking of fcache, I'll find you some good links to read on that and the memory models in the next post.
Fcache is explained at the bottom of that page, here: https://github.com/parallaxinc/propgcc-docs/blob/master/doc/Memory.md#miscellaneous-functions
When using a PropWare-based application, fcache is a bit easier to use thanks to some macros defined in PropWare.h. Here's an example:
/** * @brief Shift out one word of data (FCache function) * * @param[in] data A fully configured, ready-to-go, data word * @param[in] bits Number of shiftable bits in the data word * @param[in] bitCycles Delay between each bit; Unit is clock cycles * @param[in] txMask Pin mask of the TX pin */ inline void shift_out_data (uint32_t data, uint32_t bits, const uint32_t bitCycles, const uint32_t txMask) const { volatile uint32_t waitCycles = bitCycles; __asm__ volatile ( FC_START("ShiftOutDataStart%=", "ShiftOutDataEnd%=") " add %[_waitCycles], CNT \n\t" "loop%=: \n\t" " waitcnt %[_waitCycles], %[_bitCycles] \n\t" " shr %[_data],#1 wc \n\t" " muxc outa, %[_mask] \n\t" " djnz %[_bits], #" FC_ADDR("loop%=", "ShiftOutDataStart%=") " \n\t" FC_END("ShiftOutDataEnd%=") : [_data] "+r"(data), [_waitCycles] "+r"(waitCycles), [_bits] "+r"(bits) : [_mask] "r"(txMask), [_bitCycles] "r"(bitCycles)); }FC_START, FC_END, and FC_ADDR help to deal with the fact that addresses are a bit wonky in fcache, but you can see their definitions here. You can also see example of fcache without PropWare's macros in libpropeller's I2C objects.
LMM: Large Memory Model - The code is compiled as PASM with a few small differences. It is executed by a small "interpreter" that handles fetching the next instruction, executing it, and dealing with branches. The interpreter is incredibly thin, so this is almost a real PASM instruction every 16 clocks.
CMM: Compressed Memory Model - The code is compiled to a set of instruction tokens that are smaller than 32 bits, much like Spin, but the compiler includes Gcc's optimizer, and the interpreter is about 2x faster than Spin or so.
XMM: eXtended Memory Model - This uses an SD card to hold code larger than the 32kb Prop memory. Code is compiled like LMM, but the interpreter includes code to pull pages on demand from the SD card, and needs an SD driver cog, so it's considerably slower, and has more overhead than straight LMM, but overcomes the 32kb limit of the Prop. Not used often.
XMM, LMM and CMM, depending on the compiler options, can benefit from the use of the FCache, which is a small area of cog ram set aside for raw PASM code, like inner loops, that benefit from running without interpreter overhead. I *think* the FCache is larger on LMM code because it has a smaller interpreter, but I may be wrong there - hopefully @ERSmith or someone who knows more will correct this if I'm off here. Code compiled for the FCache uses real PASM, so it's 32-bits per instruction, unlike CMM, so CMM set to "optimize for size" won't use this, but "optimize for speed" will, where possible.
I think I will read the 'Propeller Programming' book recommended by Frank, and then be back with more questions.
DavidZ, The PropWare looks great, may end up going with that eventually, I do like the simplicity of the command line for many operations in Linux. I am also going to be spending a lot of time reading all the links your information has unearthed. First quick question - from my first perusal, it looks like the fcashe is simply a way to use PASM in-line, is that correct?
It also looks like one can use PASM in it's own cog simply by using SimpleIDE and appending a '.cog' (or something like that, have lost the area where I read this...) on the name of the file. It will probably be explained in the 'Propeller Programming' book, but does anyone have a quick description of how to exchange data between the PASM cog and C program running in another cog (use malloc() and somehow pass that address)? How to start and stop the PASM cog?
Thanks again,
Nate
For all intents and purposes, yes. I do think it's important to remember that fcache has to first copy your entire block of code from HUB to COG RAM and then execute it. I think it's important to remember that bit of overhead so you don't overuse it for simple 2 or 3 instruction routines.
SimpleIDE isn't the only special snowflake that can do .cog objects
Okay, so how do you start code in a new cog? You have options:
PropGCC's raw cognew() and coginit()
cognew(code, param) is simply a light wrapper around coginit(0x08, code, param). This should look very familiar for the avid PASM programmer. Generally not advisable for cogs running "high level" C or C++ code because that code will need access to a stack... a stack which doesn't exist for that cog. These are primarily useful for kicking off cogc/cogcpp or raw assembly drivers
PropGCC's cogstart()
cogstart(func, par, stack, stacksize) is far more useful for running high-level code in another cog. This method will takes a function pointer as the first parameter and will start up a new cog and give it stack space per the third and fourth parameters. And of course, you have the "par" parameter for your mailbox variable as usual.
Simple's cog_run()
cog_run(function, stacksize) gives you an easier-to-invoke wrapper around cogstart(). This takes a function pointer and integer value for the stacksize only. No mailbox parameter! And note that this function will use malloc for allocating the stack too... so be careful about code size
PropWare's PropWare::Runnable
This class gives you (what I think is) easy and object-oriented access to running code in different cogs. Simply create a class that inherits from PropWare::Runnable and then kick it off with PropWare::Runnable::invoke(myCoolObject). An example of its use is provided in the docs.
Whew! That's all that I can think of off the top of my head.
In that case one can write Spin using Vim with syntax highlighting: http://forums.parallax.com/discussion/118328/spin-syntax-definition-for-vim
For command line compilation we have OpenSpin, BST and Homespun.
https://github.com/ZiCog/HomeSpun
For pure PASM only programs there is Cliff Biffles PASM assembler, propasm:
https://github.com/cbiffle/propasm
A little searching will find a bunch of command line loaders for the Propeller.
There is a lot of tools for the Propeller that run on Linux. Sadly they are not always as high profile as we would like.
DavidZ, I will give propWare's PropWare::Runnable a good look. I have never gotten much into C++ (only C), it may be what I am looking for. I have always been a little unimpressed with the clunky way SPIN/PASM had to use the PAR long to setup the communication pipeline - I always had confusion keeping track of bytes/words/longs and exactly which data I had stashed where.
To clarify, my understanding is that in-line PASM is fast, but not totally deterministic, while a cog running PASM (excepting main ROM reads/writes) is. Yes?
Heater, I switched to Linux after the Microsoft you-WILL-upgrade-to-Windows10 craziness, and have never looked back. However, I have never embraced all these wacky keyboard-shortcut editors, I pretty much hate both vi and emacs. I use xed/gedit (ducks and runs for exit -->)
The very useful thing about BST is that it produces a real listing which is important for me since I need to optimize the memory map of my Tachyon kernel.
Except a year ago I was coerced into using Win 10 on a Surface Pro. I was pleased to find that it runs all my old favorite programs from Linux world. And now has a BASH shell built in. It's only blue screened once, which happened to be yesterday in the middle of a rather important meeting. The programs it does have problems with are all Windows applications!
Folks round here think I have gone senile since I stopped bashing on Windows so much.
The other problem I have with Windows is not so much Windows itself but the NTFS file system. The problem is when it has a problem, it can be a real problem and it seems like you have to run Windows to fix the problem. The problem is Windows doesn't want to run because it encounters a problem. You see the problem?
I do which Windows file systems had sensible access rights. Changing permissions on a file confused git which then confuses me as a file is said to have changed when it has not. Luckily git has an option to ignore that particular Windows failing.
Sometimes I have to bash on BASH on Windows as it does not work as well as BASH on Linux/Unix yet. And of course not everything you want to do with BASH is doable with BASH on Windows due to limitations of the underlying Windows OS.
This is from (shameless plug) my book on leanpub
Propeller Programming. I hope that can help you get started. I also discuss cog-c and c-pasm programming in there.
Sincerely,
Sridhar