View source for Parallax Propeller

{{Short description|Multi-core microcontroller}}
[[File:Propeller Chip.JPG|thumb|Parallax Propeller in [[dual in-line package]]]]
[[File:Propeller P8X32A IC.jpg|thumb|Parallax Propeller in [[TQFP]]]]
The '''Parallax P8X32A Propeller''' is a [[multi-core processor]] [[parallel computing|parallel]] [[computer architecture]] [[microcontroller]] chip with eight [[32-bit]] [[reduced instruction set computer]] (RISC) [[central processing unit]] (CPU) cores.<ref>{{cite web |url=http://blog.makezine.com/archive/2006/02/first_look_at_parallaxs_propel.html |title=First look at Parallax's Propeller chip |first=Phillip |last=Torrone |date=February 18, 2006 |website=[[Make (magazine)|Make]] blog |archive-url=https://web.archive.org/web/20080625000611/http://blog.makezine.com/archive/2006/02/first_look_at_parallaxs_propel.html |archive-date=2008-06-25 |url-status=dead}}</ref><ref>{{cite web |url=http://blog.makezine.com/2006/08/21/parallax-propeller-review/ |title=Parallax Propeller (review) |first=Phillip |last=Torrone |date=August 21, 2006 |website=[[Make (magazine)|Make]]}}</ref> Introduced in 2006, it is designed and sold by [[Parallax, Inc. (company)|Parallax, Inc.]]

The Propeller microcontroller, Propeller [[assembly language]], and Spin [[Interpreter (computing)|interpreter]] were designed by Parallax's cofounder and president, Chip Gracey. The Spin [[programming language]] and ''Propeller Tool'' [[integrated development environment]] (IDE) were designed by Chip Gracey and Parallax's software engineer Jeff Martin.

On August 6, 2014, Parallax Inc. released all of the Propeller 1 P8X32A hardware and tools as [[open-source hardware]] and [[open-source software|software]] under the [[GNU General Public License]] (GPL) 3.0. This included the [[Verilog]] code, top-level [[hardware description language]] (HDL) files, Spin interpreter, PropellerIDE and SimpleIDE programming tools and compilers.<ref>{{cite web |url=https://www1.parallax.com/microcontrollers/propeller-1-open-source |title=Propeller 1 Open Source |last=Gracey |first=Ken |date=2014 |website=Parallax Inc. |publisher=Parallax Inc. |access-date=23 January 2021 |quote=The Propeller 1 (P8X32A) is now a 100% open multicore microcontroller, including all of the hardware and tools ... The Propeller 1 may be the most open chip in its class.}}</ref>

In 2020, the [[Parallax Propeller 2]] (P2X8C4M64P) was released.

==Multi-core architecture==
Each of the eight 32-bit cores (termed a ''cog'') has a [[central processing unit]] (CPU) which has access to 512 32-bit long [[Word (data type)|words]] (2&nbsp;[[Kilobyte|KB]]) of instructions and data. [[Self-modifying code]] is possible and is used internally, for example, as the [[boot loader]] overwrites itself with the Spin Interpreter.  Subroutines in Spin (object-based high-level code) use a call-return mechanism requiring use of a call [[Stack (abstract data type)|stack]].  Assembly (PASM, low-level) code needs no call stack.  Access to shared memory (32&nbsp;KB [[random-access memory]] (RAM); 32&nbsp;KB [[read-only memory]] (ROM)) is controlled via [[round-robin scheduling]] by an internal [[computer bus]] controller termed the ''hub''. Each cog also has access to two dedicated hardware counters and a special ''video generator'' for use in generating timing signals for [[PAL]], [[NTSC]], [[VGA]], [[servomechanism]]-control, and others.<ref>{{Cite web |url=https://www.electronicdesign.com/technologies/boards/article/21754713/eied-online-parallax-propeller |title=EiED Online>> Parallax Propeller |first=William G. |last=Wong |date=December 15, 2022}}</ref>

==Speed and power management==
The Propeller can be [[system time|clocked]] using either an internal, on-chip oscillator (providing a lower total part count, but sacrificing some accuracy and [[Thermodynamics|thermal]] stability) or an external [[crystal oscillator]] or [[ceramic resonator]] (providing higher maximum speed with greater accuracy at higher total cost). Only the external oscillator may be run through an on-chip [[phase-locked loop]] (PLL) [[clock multiplier]], which may be set at 1x, 2x, 4x, 8x, or 16x.

Both the on-board oscillator frequency (if used) and the PLL multiplier value may be changed at run-time. If used correctly, this can improve power efficiency; for example, the PLL multiplier can be decreased before a long ''no operation'' wait needed for timing purposes, then increased afterward, causing the processor to use less power. However, the utility of this technique is limited to situations where no other cog is executing timing-dependent code (or is carefully designed to cope with the change), since the effective clock rate is common to all cogs.

The effective clock rate ranges from 32&nbsp;kHz up to 80&nbsp;MHz (with the exact values available for dynamic control dependent on the configuration used, as described above). When running at 80&nbsp;MHz, the proprietary interpreted ''Spin'' programming language executes approximately 80,000 instruction-tokens per second on each core, giving 8 times 80,000 for 640,000 high-level instructions per second. Most machine-language instructions take 4 clock-cycles to execute, resulting in 20 million [[instructions per second]] (MIPS) per cog, or 160&nbsp;MIPS total for an 8-cog Propeller.

Power use can be reduced by lowering the clock rate to what is needed, by turning off unneeded cogs (which then use little power), and by reconfiguring I/O pins which are unneeded, or can be safely placed in a [[high-impedance]] state (''[[Three-state logic|tristated]]''), as inputs. Pins can be reconfigured dynamically, but again, the change applies to all cogs, so synchronizing is important for certain designs. Some protection is available for situations where one core attempts to use a pin as an output while another attempts to use it as an input; this is explained in Parallax's technical reference manual.

==On-board peripherals==
Each cog has access to some dedicated counter-timer hardware, and a special timing signal generator intended to simplify the design of video output stages, such as composite [[PAL]] or [[NTSC]] displays (including [[modulation]] for broadcast) and [[Video Graphics Array]] (VGA) monitors. Parallax thus makes sample code available which can generate video signals (text and somewhat low-resolution graphics) using a minimum parts count consisting of the Propeller, a crystal oscillator, and a few resistors to form a crude [[digital-to-analog converter]] (DAC). The frequency of the oscillator is important, as the correction ability of the video timing hardware is limited to the clock rate. It is possible to use multiple cogs in parallel to generate a single video signal. More generally, the timing hardware can be used to implement various [[pulse-width modulation]] (PWM) timing signals.

==ROM extensions==
In addition to the Spin interpreter and a [[boot loader]], the built-in ROM provides some data which may be useful for certain sound, video, or [[mathematics]] applications:
* a bitmap [[font]] is provided, suitable for typical character generation applications (but not customizable);
* a [[logarithm]] table (base 2, 2048 entries);
* an [[antilog]] table (base 2, 2048 entries); and
* a sine table (16-bit, 2049 entries representing first quadrant, angles from 0 to π/2; other three quadrants are created from the same table).

The math extensions are intended to help compensate for the lack of a [[floating-point unit]], and more primitive missing operations, such as multiplication and division (this is masked in Spin but is a limit for [[assembly language]] routines). The Propeller is a 32-bit processor, however, and these tables may have insufficient accuracy for higher-precision uses.

==Built in Spin bytecode interpreter==
Spin is a [[Computer multitasking|multitasking]] [[High-level programming language|high-level]] [[computer programming language]] created by [[Parallax, Inc. (company)|Parallax]]'s Chip Gracey, who also designed the Propeller [[microcontroller]] on which it runs, for their line of Propeller microcontrollers.<ref>{{cite journal |url=http://portal.acm.org/citation.cfm?id=1289314 |first1=David A. |last1=Scanlan |first2=Martin A. |last2=Hebel |title=Programming the eight-core propeller chip |journal=[[Journal of Computing Sciences in Colleges]] |volume=23 |issue=1 |pages=162–168 |date=October 2007}}</ref>

Spin code is written on the Propeller Tool, a GUI-oriented software development platform written for Windows XP.<ref>{{cite web |url=http://propeller.wikispaces.com/Prop%2BTool |title=Prop Tool |website=Propeller wiki at [[Wikispaces]] |archive-url=https://web.archive.org/web/20081001222323/http://propeller.wikispaces.com/Prop%2BTool |archive-date=2008-10-01 |url-status=dead}}</ref> This compiler converts the Spin code into [[bytecode]]s that can be loaded (with the same tool) into the main 32&nbsp;KB RAM, and optionally into the [[I²C]] boot ''electrically erasable programmable read-only memory'' ([[EEPROM]]), of the Propeller chip. After booting the propeller, a bytecode interpreter is copied from the built in ROM into the 2&nbsp;KB RAM of the primary COG. This COG will then start interpreting the bytecodes in the main 32&nbsp;KB RAM. More than one copy of the bytecode interpreter can run in other COGs, so several Spin code [[Thread (computer science)|threads]] can run simultaneously. Within a Spin code program, assembly code program(s) can be ''[[inline function|inline]]'' inserted. These assembler program(s) will then run on their own COGs.

Like [[Python (programming language)|Python]], Spin uses indentation whitespace, rather than [[curly braces]] or [[Keyword (computer programming)|keywords]], to delimit [[Block (programming)|blocks]].

The Propeller's interpreter for its proprietary [[Thread (computer science)|multi-threaded]] Spin computer language is a [[bytecode]] interpreter. This interpreter decodes strings of instructions, one instruction per [[byte]], from user code which has been edited, compiled, and loaded onto the Propeller from within a purpose-specific [[integrated development environment]] (IDE). This IDE, which Parallax names ''The Propeller tool'', is intended for use under a [[Microsoft Windows]] operating system.

The Spin language is a [[high-level programming language]]. Because it is interpreted in software, it runs slower than pure Propeller assembly, but can be more space-efficient: Propeller assembly opcodes are 32 bits long; Spin directives are 8 bits long, which may be followed by a number of 8-bit bytes to specify how that directive operates.

At startup, a copy of the bytecode interpreter (less than 2&nbsp;KB in size), will be copied into the dedicated RAM of a cog and will then start interpreting bytecode in the main 32&nbsp;KB RAM. Additional cogs can be started from that point, loading a separate copy of the interpreter into the new cog's dedicated RAM (a total of eight interpreter threads can, thus, run simultaneously). Notably, this means that at least a minimal amount of startup code ''must'' be Spin code, for all Propeller applications.

===Syntax===
Spin's syntax can be divided into blocks, which hold:
* ''VAR'' – global variables
* ''CON'' – program constants
* ''PUB'' – code for a public subroutine
* ''PRI'' – code for a private subroutine
* ''OBJ'' – code for objects
* ''DAT'' – predefined data, memory reservations and assembly code

===Example keywords===
* ''reboot:'' causes the microcontroller to reboot
* ''waitcnt:'' wait for the system counter to equal or exceed a specified value
* ''waitvid:'' waits for a (video) timing event before outputting (video) data to I/O pins
* ''coginit:'' starts a processor on a new task

===Example program===
An example program, (as it would appear in the ''Propeller Tool'' editor) which emits the current system counter every 3,000,000 cycles, then is shut down by another cog after 40,000,000 cycles:

[[File:Example SPIN program.png]]

==Package and I/O==
The initial version of the chip (called the P8X32A) provides one 32-bit port in a 40-pin 0.6&nbsp;in [[dual in-line package]] (DIP), 44-pin [[LQFP]], or [[Quad Flat No-leads package]] (QFN) [[surface-mount technology]] package. Of the 40 available pins, 32 are used for I/O, four for power and ground pins, two for an external crystal (if used), one to enable [[power outage]] and brownout detection, and one for reset.

All eight cores can access the 32-bit port (designated "A"; there is currently no "B") simultaneously. A special control mechanism is used to avoid I/O conflicts if one core attempts to use an I/O pin as an output while another tries to use it as input. Any of these pins can be used for the timing or pulse-width modulation output techniques described above.

Parallax has stated that it expects later versions of the Propeller to offer more I/O pins and/or more memory.<ref name="moremips">{{cite web |url=http://forums.parallaxinc.com/forums/default.aspx?f=25&m=156993 |title=Parallax Forums message |website=Parallax Forums}}{{dead link|fix-attempted=yes|date=December 2022}}</ref>

==Virtual I/O devices==
[[File:prop grap demo.gif|256px|right|thumb|Screen capture of the graphics demo that Parallax created to demonstrate the NTSC video library]]
The Propeller's designers designed it around the concept of "virtual I/O devices". For example, the ''[[HYDRA Game Development Kit]]'', (a computer system designed for hobbyists, to learn to develop retro-style video games) uses the built-in character generator and video support logic to generate a [[Virtual machine|virtual]] [[graphics processing unit]]-generator that outputs VGA color pictures, PAL/NTSC compatible color pictures or broadcast RF video+audio in software.<ref>{{cite web |url=http://www.selmaware.com/propeller_video_app_board.htm |title=Propeller Video Application Board PCB |website=SelmaWare Solutions |archive-url=https://web.archive.org/web/20081221183043/http://selmaware.com/propeller_video_app_board.htm |archive-date=2008-12-21 |url-status=dead}}; a dedicated video generator board with a propeller</ref>

The screen capture displayed here was made using a software ''virtual display driver'' that sends the pixel data over a serial link to a PC.<ref>{{cite web |url=http://forums.parallaxinc.com/forums/pr.aspx?f=33&m=198032 |title=Parallax Forums post about screen capture software |website=Parallax Forums |archive-url=https://archive.today/20120709061514/http://forums.parallaxinc.com/forums/pr.aspx?f=33&m=198032 |archive-date=2012-07-09 |url-status=dead}}</ref>

Software libraries are available to implement several I/O devices ranging from simple UARTs and Serial I/O interfaces such as SPI, I²C and PS/2 compatible serial mouse and keyboard interfaces, motor drivers for robotic systems, MIDI interfaces and LCD controllers.<ref>{{GitHub|https://github.com/parallaxinc/propeller/tree/master/libraries/community/p1}}; Propeller object exchange software library</ref>

==Dedicated cores instead of interrupts==
The design philosophy of the Propeller is that a [[hard real-time]] multi-core architecture negates the need for dedicated [[interrupt]] hardware and support in assembly. In traditional CPU architecture, external interrupt lines are fed to an on-chip interrupt controller and are serviced by one or more [[interrupt service routine]]s. When an interrupt occurs, the interrupt controller suspends normal CPU processing and saves internal state (typically on the stack), then vectors to the designated interrupt service routine. After handling the interrupt, the service routine executes a ''return from interrupt'' instruction which restores the internal state and resumes CPU processing.

To handle an external signal promptly on the Propeller, any one of the 32 I/O lines is configured as an input. A cog is then configured to wait for a transition (either positive or negative edge) on that input using one of the two counter circuits available to each cog. While waiting for the signal, the cog operates in low-power mode, essentially sleeping. Extending this technique, a Propeller can be set up to respond to eight independent ''[[interrupt]]'' lines with essentially zero handling delay. Alternately, one line can be used to signal the interrupt, and then additional input lines can be read to determine the nature of the event. The code running in the other cores is not affected by the interrupt handling cog. Unlike a traditional multitasking single-processor interrupt architecture, the signal response timing remains [[Deterministic automaton|predictable]],<ref>{{cite web |url=http://propeller.wikispaces.com/Interrupts |title=Interrupts |website=Propeller wiki at Wikispaces |archive-url=https://web.archive.org/web/20100921082138/http://propeller.wikispaces.com/Interrupts |archive-date=2010-09-21 |url-status=dead}}</ref> and indeed using the term ''interrupt'' in this context can cause confusion, since this function can be more properly thought of as polling with a zero loop time.

==Boot mechanism==
On power up, [[Brownout_(electricity)|Brownout]] detection, software reset, or external hardware reset, the Propeller will load a machine-code [[booting]] routine from the internal ROM into the RAM of its first (primary) cog and execute it. This code [[emulator|emulates]] an [[I²C]] interface in software, temporarily using two I/O pins for the needed serial clock and data signals to load user code from an external I<sup>2</sup>C [[EEPROM]].

Simultaneously, it emulates a [[serial port]], using two other I/O pins that can be used to upload software directly to RAM (and optionally to the external EEPROM). If the Propeller sees no commands from the serial port, it loads the user program (the entry code of which must be written in Spin, as described above) from the serial EEPROM into the main 32&nbsp;KB RAM. After that, it loads the Spin interpreter from its built-in ROM into the dedicated RAM of its first cog, overwriting most of the bootloader.

Regardless of how the user program is loaded, execution starts by interpreting initial user [[bytecode]] with the Spin interpreter running in the primary cog. After this initial Spin code runs, the application can turn on any unused cog to start a new [[Thread (computer science)|thread]], and/or start [[assembly language]] routines.

==External persistent memory==
The Propeller boots from an external serial [[EEPROM]]; once the boot sequence completes, this device may be accessed as an external peripheral.<ref>{{cite magazine |url=http://www.circuitcellar.com/library/print/0806/Cantrell193/2.htm |title=Turning the Core-ner |first=Tom |last=Cantrell |magazine=Circuit Cellar |issue=193 |page=80 |date=August 2006 |archive-url=https://archive.today/20070628051159/http://www.circuitcellar.com/library/print/0806/Cantrell193/2.htm |archive-date=2007-06-28 |url-status=dead}}</ref>

==Other language implementations==
Apart from Spin and the Propeller's low-level assembler, a number of other languages have been ported to it.

===C compiler===
Parallax supports Propeller-GCC which is a port of the [[GNU Compiler Collection]] (GCC) compiler for the programming languages [[C (programming language)|C]] and [[C++]], for Propeller<ref>{{cite web |url=http://code.google.com/p/propgcc/ |title=PropGCC on Google Code}}</ref> (branch release_1_0). The C compiler and the C Library are ANSI C compliant. The C++ compiler is ANSI-C99 compliant. Full C++ is supported with external memory. The SimpleIDE program<ref>{{cite web |url=http://learn.parallax.com/node/640 |title=Propeller C - Set Up SimpleIDE |website=learn.parallax.com}}</ref> provides users a simple way to write programs without requiring [[Make (software)|makefiles]]. In 2013, Parallax incorporated Propeller-GCC and Simple Libraries into the Propeller-C Learn series of tutorials.<ref>{{cite web |url=http://learn.parallax.com/propeller-c |title=Propeller C |website=learn.parllax.com}}</ref> Propeller-GCC is actively maintained. Propeller-GCC and SimpleIDE are officially supported Parallax software products.

The ImageCraft ICCV7 for Propeller C compiler has been marked to end-of-life state.<ref>{{cite web |url=http://www.parallax.com/Store/Microcontrollers/PropellerTools/tabid/143/ProductID/526/List/0/Default.aspx?SortField=ProductName,ProductName |title=ICCV7 for Propeller (Non-Commercial) - End of Life |website=Parallax Inc.  |archive-url=https://web.archive.org/web/20110918171139/http://www.parallax.com/Store/Microcontrollers/PropellerTools/tabid/143/ProductID/526/List/0/Default.aspx?SortField=ProductName,ProductName |archive-date=2011-09-18 |url-status=dead}}</ref>

A free ANSI C compiler named Catalina is available.<ref>{{cite web |url=http://forums.parallaxinc.com/forums/default.aspx?f=25&m=388930 |title=Catalina - a FREE C compiler for the Propeller - The Final Frontier! |website=Parallax Forums |archive-url=https://archive.today/20120731160922/http://forums.parallaxinc.com/forums/default.aspx?f=25&m=388930 |archive-date=2012-07-31 |url-status=dead}}</ref> It is based on [[LCC (compiler)|LCC]]. Catalina is actively maintained.

===BASIC compiler===
PropBASIC is a [[BASIC]] programming language for the Parallax Propeller Microcontroller.<ref>{{Cite web|url=http://forums.parallax.com/discussion/118611/download-propbasic-here-00-01-14-last-version-for-bst|title = Download PropBASIC here... 00.01.14 LAST VERSION FOR BST |website = Parallax Forums |date = 2009-12-23}}</ref> PropBASIC requires Brad's Spin Tool (BST), a [[cross-platform]] set of tools for developing with the Parallax Propeller.  As of August 2015, BST runs on i386-linux-gtk2, PowerPC-darwin ([[macOS|Mac OS X]] 10.4 through 10.6), i386-darwin (Mac OS X 10.4 through 10.6) and i386-Win32 ([[Windows 95]] through [[Windows 7]]).

===Forth on the Propeller===
There are at least six different versions of [[Forth (programming language)|Forth]], both [[Commercial software|commercial]] and [[open-source software]], available for the Propeller.

====PropForth====
A free version that enjoys extensive development and community support is PropForth.<ref>{{cite web |url=http://code.google.com/p/propforth/|title=propforth |website=code.google.com}}</ref> It is tailored to the prop architecture, and necessarily deviates from any general standard regarding architectural uniqueness, consistent with the concept of Forth.

Beyond the Forth interpreter, PropForth provides many features that exploit the chip's abilities. ''Linked I/O'' refers to the method of associating a stream with process, allowing one process to link to the next on the fly, transparent to the application. This can reduce or eliminate the need of a hardware debugging or [[JTAG]] interface in many cases. ''Multi-Channel Synchronous Serial'' (MCS) refers to the synchronous serial communication between prop chips. 96-bit packets are sent continuously between two cogs, the result is that applications see additional resources (+6 cogs for each prop chip added) with little or no impact on throughput for a well constructed application.

''LogicAnalyzer'' refers to an extension package that implements software logic analyzer. EEPROMfilesystem and SDfilesystem are extensions that implement rudimentary storage using EEPROM and SD flash.

''PagedAssembler'' refers to the package of optimizations that allow assembler routines to be swapped in (and out by overwrite) on the fly, allowing virtually unlimited application size. Script execution allows extensions to be loaded on the fly, allowing program source up to the size of storage media.

===Propeller and Java===
There are efforts underway to run the [[Java virtual machine]] (JVM) on Propeller. A compiler, debugger, and emulator are being developed.<ref>{{cite web |url=http://propeller.wikispaces.com/Programming%2Bin%2BJava |title=Programming in Java |website=Propeller wiki at Wikispaces |archive-url=https://web.archive.org/web/20081004172911/http://propeller.wikispaces.com/Programming%2Bin%2BJava |archive-date=2008-10-04 |url-status=dead}}</ref>

===Pascal compiler and runtime===
A large subset of [[Pascal (programming language)|Pascal]] is implemented by a compiler and interpreter based on the [[p-code machine]] P4 system.<ref>{{cite web |url=http://propeller.wikispaces.com/Programming%2Bin%2BPascal |url-status=dead |archive-url=https://web.archive.org/web/20081004050629/http://propeller.wikispaces.com/Programming%2Bin%2BPascal |archive-date=2008-10-04 |title=Programming in Pascal |website=Propeller wiki at Wikispaces}}</ref>

==Graphical programming==
[[File:PICoPLC ladder editor v3.0 screenshot.png|300px|right|thumb|Screen capture of the PICoPLC ladder editor]]
PICo [[programmable logic controller]] (PLC, PICoPLC) supports output to Propeller processor. The program is created in a GUI [[ladder logic]] editor and resulting code is emitted as Spin source. PICoPLC also supports P8X32 with create-simulate-run feature. No restrictions on target hardware as the oscillator frequency and IO pins are freely configurable in the ladder editor. PICoPLC developer website ([https://www.evotronics.eu/picoplc//]).

==Future versions==
{{As of|2014}}, Parallax is building a new Propeller<ref>{{cite web |url=https://www.parallax.com/product/propeller-2 |title=Propeller 2 |website=Parallax Inc.|date=23 July 2020 }}</ref> with cogs that each will run at about 200&nbsp;MIPS, whereas the current Propeller's cogs each run at around 20&nbsp;MIPS. The improved performance would result from a maximum clock speed increase to 200&nbsp;MHz (from 80&nbsp;MHz) and an architecture that pipelines instructions, executing an average of nearly one instruction per clock cycle (approximately a ten-fold increase).<ref name = "moremips"/>

==References==
{{Reflist}}
<!--This article uses the Cite.php citation style. If you need more information on how to add footnotes to this article, see http://meta.wikimedia.org/wiki/Cite/Cite.php -->

==External links==
{{commonscat}}
* {{Official website|www.parallax.com/microcontrollers/propeller}}, Parallax Inc:
* [https://web.archive.org/web/20080915082552/http://propeller.wikispaces.com/ Wiki with detailed information about the propeller]
* [http://forums.parallax.com/forumdisplay.php?f=65 Propeller forum at Parallax Inc:]
* [https://sites.google.com/site/propellergcc/ Propeller GCC Beta Site]
* [https://web.archive.org/web/20070126205642/http://www.electronicdesign.com/Articles/Index.cfm?AD=1&ArticleID=13329 Article at EiED online]
* [https://web.archive.org/web/20070123083348/http://www.electronicdesign.com/Articles/Index.cfm?AD=1&AD=1&ArticleID=12235 a second article at EiED online]
* [http://www.ferret.com.au/c/R-T-Nollet/Eight-cogs-in-one-chip-n677148 An article at ferret.com.au]
* [https://web.archive.org/web/20110928104254/http://forums.parallax.com/showthread.php?113091 List of programming languages running on the Propeller]
* [http://www.apstech.hu/download Download PICoPLC from APStech]{{dead link|date=March 2018 |bot=InternetArchiveBot |fix-attempted=yes }}
* [http://FirstSpin.tv/ FirstSpin, a weekly educational audio program about the Spin programming language and the Propeller, sponsored by Parallax]
{{Microcontrollers}}

{{Authority control}}

[[Category:Microcontrollers]]
[[Category:Parallax, Inc. products]]
[[Category:Open-source hardware]]
[[Category:Open microprocessors]]