I recently wrote about the Nyuzi Processor, referring a Phoronix article. Commenter Timothy Miller was kind enough to point out that the source article fails to recognize Jeff Bush as the author of the Nyuzi Processor.
Visiting his github page, reveals a set of interesting project, including another CPU design, RotorCPU, as well as an experimental, albeit old, x86 operating system. All in all, a nice set of repos to browse through.
Michael Steil from pagetable just posted a nice article on the art of migrating software to newer systems. Basically, he has built the code of a project started back in 1995 today. The code base has gone through both the changing of implementation language (twice) as well as being lost and then recovered again.
The outcome, the C64 assembler mxass, is available on github. Michael actually spent time recreating a commit history, so that you can follow the development of the code base.
Finally, as a warning, this is not meant to be used for C64 development today. There are better tools, such as cc65.
A GPGPU is a graphical processing unit, but with adaptations to make it possible to use it for general purpose computing as well. For those of you who followed Intel’s Larrabee project – that is a GPGPU. Intel’s project was stopped before it reached the market. Not an open source project, the Nyuzi Processor, implements a similar architecture.
The project is quite impressive. It features a pipeline vector FPU, multiprocess support, an L1/L2 cache hierarchy. It also comes with a LLVM-based C++ toolchain, software libraries and test benches and can be synthesized.
Check out the github page for instructions, the full Verilog source and all the associated tooling.
Matt Godbolt has created an intriguing webpage letting you enter C++ code and then watch the resulting assembly code. You can try it right here.
The compilers supported are gcc, lcc and clang in various versions. Hardware target architectures are ARM, ARM64, AVR, PowerPC and x86. Not all combinations of compilers and architectures are available, but this is enough to spend some time experimenting.
You can also enter compiler optimizations. This lets you discover how intelligent modern compilers are. It is nice to see how complex you can go and still get a pre-calculated constant back.
The code for the whole setup is available on github, and other languages than C++ can be explored. For instance, here is a version for go.
The ARM PRO MINI is a tiny, open source, board based on a Cortex M0 MCU. The whole project, including schematics and BOM, is available on github.
The MCU is an NXP ARM M0 LPC11U35FHI33/501. This means that the Eclipse-based LPCXpresso IDE can be used to develop code in C/C++. Another alternative is to use the ARMmbed Online IDE (you will have to register to get to the compiler section, it is free). The ARM PRO MINI comes with a convenience library, making development easy.
The pins can be multiplexed between various functions, so the potential configurations differ a bit. The possibilities can be summarized as follows:
- 0-8 ADC channels
- Up to 26 GPIO pins
- 0-2 SPI interfaces
- 0-1 UARTs
- 0-1 I2C interfaces
- 1 USB port
- Power pins (4.5-16V in, regulated 3.3V and 5V out)
Just in from Raspberry Pi Foundation:
Let’s get the good stuff out of the way above the fold. Raspberry Pi 2 is now on salefor $35 (the same price as the existing Model B+), featuring:
- A 900MHz quad-core ARM Cortex-A7 CPU (~6x performance)
- 1GB LPDDR2 SDRAM (2x memory)
- Complete compatibility with Raspberry Pi 1
Because it has an ARMv7 processor, it can run the full range of ARM GNU/Linux distributions, including Snappy Ubuntu Core, as well as Microsoft Windows 10.
What does this mean? It means more power, more software and the same interfaces.
The new CPU is a quadcore ARMv7 CPU, meaning that standard Linux distros as well as Windows 10 works on the platform (why would you want to tinker with Windows when you have Linux is beyond me, but anyway).
The RAM has doubled to 1GB, which is great. If nothing else, it can be used to cache more data from disk. Because, let’s be honest about this, the biggest problem with the Pi right now is the I/O speed of SD cards. A small eMMC would have been a welcome addtion.
While considering all this shiny stuff, it is also important to notice that the original Raspberry Pi will remain in production. This is important for many, many customers using this in a wide range of applications.
A friend of mine, kralleman, is crazy about retro games and their hardware. I mean properly crazy. Crazy enough to appear on national TV, as well as having three episodes of a local retro gaming show dedicated to his own collection (1, 2, 3). He is also a part of the team running the RetroSpelsMässan in Gothenburg. Go visit it if you have the chance!
He recently purchased a classic Atari Breakout table that needs repairs. I had the opportunity to have a look the main logic board of the game. This is amazing. TTL 74′ chips in long rows. So, without further ado, enjoy!
As things become more and more mobile, portable, or even wearable, power consumption becomes important. FreeRTOS moves in this direction by supporting a tickless idle process. But first, what is really the problem?
When a system has nothing to do, it goes to the idle task. This can be a simple loop, doing nothing. Doing nothing, however, consumes power. One way to attack this is to reduce the performance of the processor while in the idle task. However, in most modern OSs, including FreeRTOS, there is a timer task running. This means that the processor leaves the idle task quite frequently, using power.
To get away from this, FreeRTOS supports a tickless idle task. By setting the configUSE_TICKLESS_IDLE, the idle task suppresses ticks and the processor stays in a low power mode for as long as possible.
The actual implementation relies on a function called portSUPPRESS_TICKS_AND_SLEEP. This method is highly CPU specific and is currently supported on ARM Cortex-M3 and ARM Cortex-M4 ports. If you happen to use FreeRTOS on a different piece of silicon, you can implement the function yourself.
Dirk Grappendorf has been working on a serious looking MOS 6502 based computer. Over at his site, you can follow his development diary.
The computer was developed between September 2014 and January 2015. Quite impressive, given the outcome! The entire design is available from Dirk’s git repository over at github.
Starting with the exterior, the machine lives in a 3D printed case (love the orange!). The keyboard has been salvaged, but the original circuitry has been replaced. This is a computer resembling the C64 and similar, but with Windows keys :-)
Looking into the hardware, the machine even contains a proper SID chip for that classic chip tune sound.
The finish of the hardware and case are impressive. So is the software. It includes everything expected from a mid-80’s home computer, including a BASIC interpreter. It is also possible to develop using C or assembler.
As you probably know, the combination of retro computing and tinkering with embedded platforms tickles the mind of us here at DigitalFanatics. Someone who really hit that spot is Maurizio Ramondo and his Amiga Drive project.
Basically, it is about using a RaspberryPi as an Amiga floppy drive emulator. All the schematics and software are available for free. The schematics are for Eagle.
The system consists of two parts – an interface board, letting the Raspberry Pi speak to the Amiga via the Floppy connector, and the Raspberry Pi software, emulating two Amiga floppy drives. The result is a system that can hold two disks at a time, but it also sports a change button, allowing you to switch to two new disks. This lets you play large games such as Monkey Island (four floppies, 720kB each, so almost 3MB).