Parallax Propeller microcontroller-based mini-computer

    The Parallax microcontroller called Propeller , in comparison with the "classics" of the genre like PIC or AVR, occupies a somewhat strange niche. About the first two, we can say that these are general-purpose architectures. The creators of the Propeller approached the issue “from the flank”.

    The main distinguishing features of the Propeller:
    • 8 independent cores working in parallel. Any separation of time necessary for shared resources such as memory or I / O ports is not controlled by the programmer and is “wired” into the crystal. This gives predictability in code execution time. Each core (cog) has 4KB of its own isolated RAM. Each core also has a built-in hardware module for generating (attention!) A TV or VGA video signal.
    • There is no concept of interruptions. Instead, it is proposed to run competing tasks in different kernels (cogs).
    • You can program in either assembler or in a special high-level language Spin, which greatly simplifies multi-core and parallel programming. The Spin interpreter is wired into a crystal.
    • There is almost no concept of programming or chip firmware. The upper half of the 32KB address space (ROM) is flashed by the Spin interpreter and various system tables. In this case, each time it is turned on, it requires downloading the program from the outside (for example, from the development environment) to the lower 32KB region (RAM). But usually in real use, an external I2C EEPROM memory chip is connected, the contents of which are automatically copied to RAM when the chip is turned on.
    • The processor is declared as 32-bit, as it operates with data of this size, but the address space is 16-bit (64KB).

    The Spin language is designed for convenient multiprocessor programming, and looks like a cross between a procedural and an object-oriented language.

    Here is an example of Spin code that launches a function to spin on multiple cores. The code is really simple and straightforward.

          _clkmode = xtal1 + pll16x         'Establish speed
          _xinfreq = 5_000_000              '80Mhz
          led: "E555_LEDEngine.spin"        'Include LED methods object
          byte Counter                      'Establish Counter Variable
          long stack[90]                    'Establish working space
        PUB Main
          cognew(Twinkle(16,clkfreq/50), @stack[0])    'start Twinkle cog 1
          cognew(Twinkle(19,clkfreq/150), @stack[30])  'start Twinkle cog 2
          cognew(Twinkle(22,clkfreq/100), @stack[60])  'start Twinkle cog 3
        PUB Twinkle(PIN,RATE)                  'Method declaration 
          repeat                               'Initiate a master loop
            repeat Counter from 0 to 100       'Repeat loop Counter
              led.LEDBrightness(Counter, PIN)  'Adjust LED brightness 
              waitcnt(RATE + cnt)              'Wait a moment
            repeat Counter from 100 to 0       'Repeat loop Counter
              led.LEDBrightness(Counter,PIN)   'Adjust LED brightness 
              waitcnt(RATE + cnt)              'Wait a moment

    The function cognewstarts the task on three cores, parameterizing each with its own frequency and stack.

    Simplified The propeller is structured as follows: The name “Propeller” comes from its model of transferring priority to access shared resources. The Hub module, which controls the separation of time, does this in a circle, such as a spinning propeller. In this article I do not want to go deep into the Propeller itself, for this is a big topic. For those interested in the end, there are links to books in which you can get comprehensive information about this microcontroller. But I want to talk about one interesting project, which is called " Pocket Mini Computer ". This is a Propeller-based mini-computer (P8X32A) that uses the “P8X32A QuickStart” evaluation board as the basis.

    This stuff looks like this (photo from the official site):

    In fact, the author sells an evaluation board plus an expansion board that has VGA, microSD, PS / 2, sound and Wii Gameport. Optionally, you can put a 32KB SRAM RAM chip.

    The feature of the project is that the author developed the BASIC interpreter, which turns all this into a micro-computer a la 80s. BASIC written in Spin'e ( open source) The dialect is very limited, for example, there are no arrays, string and real variables, variable names are only one-letter, etc. Nevertheless, it gives access to all peripherals, including the SD card, and also allows you to run purely binary files that can be written at least on the same Spin'e, even in C (Parallax has a GCC version for Propeller), even in assembler.

    Next, a few photos of the designer, so that it is clear what is given in the set. As I already said, the basis of PMC is a ready-made P8X32A QuickStart board, so you only need to solder the expansion board.

    Almost everything is sealed.

    Sandwich assembly.

    Here is a small demo to evaluate the graphics capabilities.

    General impressions


    I can’t call it a general-purpose processor. In my subjective opinion, for the effective use of the Propeller, one must very well understand one's applied task. For example, the Propeller does not have PWM, DAC / AAC, built-in flash memory, triggers, the concept of interrupts, and the creators offer either to implement the necessary programmatically using the power of several cores, or to use specialized external microcircuits. The books at the end describe many examples of working with additional chips.

    Another thing is interesting. The creators of the Propeller were not afraid to move away from the traditional approach and tried to invest in concrete applications, almost ready-made tasks. Maybe for some projects this will come in handy. As I understand it, the Propeller is very convenient for creating all kinds of slot machines and consoles, for example, because of the built-in ability to generate high-quality television and VGA signals.

    Conclusion : An interesting architecture that definitely deserves attention.

    Constructor PMC

    Again, a double sensation. It seems to work, but BASIC obviously lacks resources, especially memory. For example, the same Maximite based on PIC32 surpasses it by a head. On it you can run at least RetroBSD , at least Radio 86RK . And the built-in MMBasic is incomparably more powerful.

    Although, for $ 39, this is a great toy for those who want to feel the Propeller, with the device already assembled.

    For a snack

    Books on the Propeller, which I read, which is with regards to architecture, and overlooked (with regards to projects). I recommend it all.

    A small and very understandable book for beginners. Describes (with pictures) interesting projects. One of the co-authors is the designer of PMC.

    Getting Started With the Propeller

    Extremely competent book in terms of architecture and understanding of the essence of the Propeller. It discusses only Spin programming, but with a full explanation of the approaches and features of the microcontroller. After reading the first chapter, you will get an almost complete understanding of architecture. Several projects are described below (this can be skipped).

    Programming the Propeller with Spin: A Beginner's Guide to Parallel Processing (Tab Electronics)

    A collection of real projects using the Propeller from its creators.

    Programming and Customizing the Multicore Propeller Microcontroller: The Official Guide At the time of this writing, the first book is only available in Kindle on Amazon at a price of two dollars, but the second and third can be found if you search.

    Also popular now: