Following an accidental deletion my Sustainable Suburbia Blog vanished from Blogger. Here is a partial restoration.
- 03/06/16–11:19: SIMPL meet SIMPLEX – Part 1 – Putting it Together
SIMPLEX – the EXtended Version Of SIMPL
So I took SIMPL running on a LaunchPad, and added a 23K256 RAM chip with 6 jumper wires and a 10K resistor:
I’m probably infringing a whole bunch of trademarks but the EXtended version of SIMPL which uses the EXternal SPI RAM will be called SIMPLEX.
Now that’s what I call subtle! With a touch of irony.
With the RAM expansion comes the need to examine and modify its contents, and so I have written a bit of code to allow the contends of the RAM to be dumped to the screen in both decimal and hexadecimal formats, with ASCII equivalent in a separate column.
Whilst the SIMPL kernel code fits into 2Kbytes – and as such may be considered as a smart interactive bootloader, the high level routines to manipulate the RAM extend this limit quite considerably.
The code I have produced is “quick and dirty” C, and I am sure it could be written more succinctly at a later date.
The decimal-dump D and hex-dump H commands are the start of a new group of high level commands to handle external memory, editing etc.
30 or so years ago, “monitor” programs were common place on the early 8-bit micros. They allowed for the direct editing of data within the RAM space of the memory map – and were a means of entering programs – one hex byte at a time. It was a welcome step up from toggle switches!
The “Editor” will use the first 8 commands of the User Words, signified by letters A through to H, each representing a high level operation. One allocation of these is as follows:
D Decimal Dump
G Go (execute from RAM)
H Hex Dump
Several of these are really just place-holders for yet to be written command functionality.
The first task of being able to examine the RAM contents has been undertaken, now its time to start looking at the process of getting code into the RAM area and then executing it from RAM.
The 23K256 has a page size of 32 bytes, which is a useful size for a phrase of SIMPL code.
Looking at the Block B and File F commands above, the block command can be used to manipulate the memory 32 bytes at a time – effectively a line of SIMPL code, whilst the File command can be used for handling multiple blocks.
The hexadecimal conversion is used both for 2 digit (<= 255) and 4-digit (256 <= x <= 65535) conversions.
I have includes a SIMPL primitive $ which takes an integer x and converts it to either 2 digit or 4 digit hex.
The dump formats make use of the modern wider terminal screen. 1K of RAM can be dumped to a single screen – of 32 lines of 32 hex bytes.
|The Hex -Dump as it appears on Termite Screen. 1K bytes of RAM data shown per screen
I have put the code for SIMPLEX_1 on this Github Gist Please note that the UART is running at a non-standard 100Kbaud instead of 115200. This is to be investigated later.
In the next post, I’ll look at more RAM operations plus actually running SIMPL code out of the external SPI RAM.
- 03/06/16–16:02: SIMPLEX – Part 2 – Running SIMPL Code out of External RAM
Running SIMPL Code out of External RAM
In part 1 I looked at the bulk access to the RAM chip using streaming mode – which takes about 3uS to access a byte. With single byte access, there is the significant overhead of setting up the read instruction and the 24 bit address – making an access about 100uS.
For this reason, I propose a block access mode which loads in a block of 32 bytes into the SIMPL input buffer and executes the code at full speed from there.
Reading in 32 bytes in streaming mode will take around 100uS and then the code will execute at full speed out of internal RAM.
Writing some Commands
B Block Read
D Decimal Dump
E Execute (Read and Go combined)
H Hex Dump
We need a simple routine to load a block from RAM – based on the existing bulk read.
I use the B command to signify a Block Read – and it takes a integer block number and loads the block into a temporary internal RAM buffer called block_array
Once the data is in the block_array buffer, it’s a simple case of pointing the interpreter at the start of that buffer and letting it execute the code.
To initiate this process, I use the G (Go) command.
The great thing about SIMPL is that the commands can be concatenated along a line so to load and run Block 0 you just need to type 0BG. You can then string these together so that multiple blocks are executed one after another 0BG1BG3BG2G etc
We could now dispense with the BG construct, and just call it E for Execute.
SIMPL has grown a lot today – and even as I author it, there’s a lot of new information and excitement to take in. It’s been a long but rewarding day getting the external RAM to work with SIMPL.
The latest code – with the ability to run code out of SRAM is on this github gist
In the next part, I look at data entry into the RAM and making a simple line editor.
- 03/09/16–09:36: Porting SIMPL to the MSP430FR4133 Launchpad.
For the last few days I have been using the entry level, MSP430G2553 Launchpad for my code development.
This was fine to begin with for basic experimentation with functions, but ultimately I knew that my proposed application would probably use on of the larger FRAM based parts, with built-in segment LCD controller.
The MSP430FR4133 Launchpad is excellent value at about $16 and it comes with a 6-digit multi-segment display, similar break-out headers to the entry level Launchpad and the means to monitor the mcu power consumption – using Energy Trace Technology.
My final application is a hand-held, battery powered instrument with LCD – so the MSP430FR4133 target is a good hardware match to the final device.
The MSP430FR4133 has 15360 bytes of FRAM memory for program storage, plus an additional 512 bytes for Information (calibration data, Identity etc). There is also 2Kbytes of RAM.
The extra RAM means that SIMPL can be run easily in the RAMspace without having to use the external RAM – most of the time. This makes the user interaction with SIMPL a lot easier, and also allows more functionality to be included.
Porting SIMPL to MSP430FR4133
The following steps had to be performed to get SIMPL to run on the ‘4133 Launchpad.
1. Increase the RAM allocation to make ful use of the 2Kbytes of RAM
2. Convert the uart routines to work with USCA0
3. Convert the spi routines to work with USCB0
4. Modify the ADC initialisation code to work with the onchip ADC_10
5. Correct the interrupt timer routines so that millis() and micros() work correctly
6. Make use of the LCD by diverting some printout to it
The code is still a work in progress, with 1, 2 & 3 above, working, and a little progress on 6 – but I have posted the latest code here on this Github Gist.
- 03/13/16–00:56: Diving Into Forth
I have always had a soft-spot for the Forth Programming Language, since first hearing about it as a sixth-former in the very early 1980s when I was running the after-school computer club on Friday afternoons.
At that time, I lived in the technological backwaters of the Isle of Man, gleaning all my information from electronics and home computing magazine articles and the occasional worthwhile BBC “Horizon” programme.
There was mention of Forth in the popular computing magazines – but it was probably the August 1980 Byte article – which originally galvanised widespread interest in using Forth.
Towards the end of my school days, an innovative Z80A based home computer the “Jupiter Ace” became available – but sadly it was a “day late and a dollar short” in those crazy, pioneering days of UK Home Computer industry – with new products announced nearly every week.
Since that 1980 article, we now have the internet, Github, open source software and hardware, ubiquitous 32-bit and 16-bit microcontrollers, FRAM memory, FPGAs and dozens of other technical innovations which should all help encourage users to have a look at Forth for digital interaction.
Getting started in Forth has never been simpler, in addition to Matthias Koch’s Mecrisp they are other downloadable packages, including 4E4th (for MSP430) and VFX/XC7 Lite (for MSP430 or ARM M4) from MPEForth.
I have focused on the above two architectures MSP430 and ARM, because a Forth implementation of the Forth 16-bit virtual machine is so much simpler – and sensible – on a 16-bit or 32-bit architecture, than on an 8-bit processor.
4E4th runs on the low cost MSP430 Launchpad – details of this implementation.
There is also AmForth for MSP430 – based on Brad Rodriguez’s camelForth.
(Although Amforth and eForth implementations for Ardunio’s 8 bit AVR are available).
Looking at FPGA implementations, there is James Bowman’s J1 Forth processor which runs on a Xilinx Spartan 6 device, or also on a Lattice iCE 40 series part – with the tool chain now entirely open source.
I also recently came across the N.I.G.E Machine – a 100MHz Forth Workstation, again based on low cost FPGA technology.
If you want to build a workstation type product – suitable FPGA hardware with PS/2 Keyboard & Mouse and VGA/XGA video output is available from Saanlima Electronics in their Spartan 6 Pepino board and also from Gadget Factory in their Papillio range of FPGA boards. If you are looking at the Gadget Factory – take time to look at their new Logic Analyser Kit
Whilst there are various Forth Interest (FIG) Groups around the world, it is probably the German, Forth-Gesellschaft e.V. who are the most active, with regular news and updates on their website
For anyone with an interest in Forth, why not spend a quiet Sunday morning browsing on what is available?
- 03/13/16–11:09: ChipStick – A Diminutive Dev Board
|Chipstick – A complete “Retro” computer on a 40 x 11mm stick|
I have recently been looking at the MSP430 as a contender for a general purpose development board. In the last 3 weeks I have looked at several of the extensive range of devices, both the low cost “value line” and other parts, including those with nonvolatile FRAM memory, 24 bit ADCs and LCD drivers. Having absorbed the data sheets of several devices I came to the following conclusions:
1. There are hundreds of MSP variants across several families.
2. Very few packages offer consistent pin-out – allowing one device to be swapped for an upgrade part.
3. Register names and bit names often lack consistency across the various families making common code more difficult.
4. You can never quite find the all peripherals you need in the package you want.
After a bit of consideration, I decided to tackle points 2 and 4 above in one hit – I will design a common carrier board allowing a common footprint.
As I like the small plug-in DIL packages, as they are breadboard and stripboard friendly. So it seemed a sensible idea to use the DIL 20 as a common footprint. I also found that some devices were available in a very compact 24pin QFN package – which is ideal for mounting at 45 degrees at the centre of a 20 pin DIL footprint.
In my search for the ideal part, I came across the new MSP430FR2xxx series. These have 15.5K of FRAM and 4K of RAM. In addition they have 2 A type UCSI and 1 B type UCSI universal serial communications interfaces.
So in a few hours, I had designed a tiny carrier board, to which I added a USB to serial converter IC plus some extra features.
The pcb is designed to take any of the 24pin MSP430FR2xxx range, but in particular the very low cost MSP430FR2433. The 20 pin DIL footprint breaks out the available pins into a form that can be plugged directly into a low cost Launchpad – in place of the MSP430G2553 device.
This gives almost 16K of nonvolatile FRAM plus 4Kbytes of SRAM – which is eight times the RAM on the ‘2553.
On the left hand end of the board is the CH340G USB to serial converter IC. This forms a complete communications and programmer interface – providing the RESET and TEST signals required for the serial bootstrap loader (BSL) programmer.
|“Chopstick” – with the Programmer section removed|
It should be noted that this programmer section of the board is detachable, making the 20pin DIL carrier part not much bigger than a standard DIL socket. A 6 way 1.27mm (0.05″) pitch connector allows the programming section to be connected to the target using a suitable cable.
The MSP430FR2433 has 3 very useful communication ports. One of these is reserved for UART communications to a PC, whist the other two can be used for SPI, I2C or other GPIO purpose.
The board also makes the following provisions:
1. A reset switch
2. A single LED
3. A 32768Hz crystal may be fitted for more accurate timing.
4. A lithium battery or super-capacitor may be plugged in to power the board
5. On the underside of the board there is a footprint to allow an external SPI SRAM or FRAM IC to be fitted. SRAM available up to 1Mbit (128Kx8) or FRAM up to 256Kx8.
In the next part, on receipt of the board back from the manufacturers, around March 23rd – I will discuss some applications for this diminutive dev-board.
Other recent Posts on ChipStick
ChipStick – A Diminutive Dev Board
- 03/14/16–17:14: The $5 FORTH Computer
The MSP430 makes an excellent choice for a Forth Computer. It already has a 16 bit architecture, and the Von Neuman unified memory space makes dealing with data and instructions somewhat simpler. It’s choice of low power, non volatile FRAM memory makes it virtually unique in the microcontroller market.
FRAM has a fast write cycle – about 100 times the speed of Flash, and with a life of 10E +14 cycles – it will not wear out anytime soon. EEprom is made redundant with FRAM, and the boundary between FRAM and SRAM can be moved – so that FRAM is used as RAM – allowing up to 8MHz operation.
The MSP430FR2433 is a new addition to the FRAM range of microcontrollers and at $1.50 it is very affordable. Add to this an external SRAM or FRAM memory and you have the makings of a powerful little machine. With volume production, it’s possible to have a complete Forth system for around $5 – including the USB programming adaptor.
Performance wise, it’s not in the ARM class, not even close, but at 16MHz full speed, it will run about 4 times the throughput of the Arduino R3.
One of it’s strengths is that it has been blessed with 3 communications ports – allowing a rich mix of asynchronous UART and synchronous SPI hardware to be added.
The MSP430 may be programmed with a variety of Forths, including Mecrisp, Amforth and 4E4th – the latter having a special port of Camel Forth available specifically for FRAM operation.
Recently I came across Fast Forth by Jean-Michel Thoorens – this is Direct Threaded Code, and has support for SD card. Programming is done making use of TeraTerm for file sending – at a full 921600 Baud. It was designed specifically for MSP430 with FRAM – needing just 8K bytes of FRAM.
Forth was designed as a complete, self contained tool-chain – including Editor, Compiler and Assembler – all the tools that you need to develop code, at your fingertips – present on the target chip. Now for the first time we can have all of this on a tiny, manageable 20 pin DIL module – complete with it’s own USB programming interface.
The communications interfaces include UART, SPI and I2C. There are up to 6 port pins available for use as GPIO, peripheral selects or ADC inputs.
Need to add more I/O? No problem – can be done using simple shift registers clocked off one of the two available SPI ports.
Want to build a WiFi or Bluetooth robot – again no problem. Just drive the stepper motors using a shift register or high power driver – such as theTPIC6B595
The SPI port may be used to read a PS/2 keyboard, or I2C will interface nicely to a Wii Nunchuck controller.
ChipStick will accept an external static RAM (23K256 or 23LC1024) up to 128Kx8, or a SPI FRAM of up to 256Kx8. In streaming mode the speed is about 3uS per byte (for long streams) allowing 32K to be transferred in 100mS.
It should even be possible to experiment with monochrome video output by clocking data out of the SRAM using SPI.
|Erm – Wrong Chipsticks!|
|ChipStick will be a fully functioning FRAM MSP430 Forth System!|
It’s nice to have a hobby in which something useful can be designed over a weekend. That’s the case with ChipStick – conceived on Friday evening after work – and off to meet it’s maker (my pcb board house) at the end of Sunday evening.
ChipStick is the solution to the modern problem that not enough microcontrollers are breadboard friendly – so I just sat down and designed what I needed – a neat 20 pin DIL module – based on the MSP430FR2433.
ChipStick is probably the smallest computer I have worked on, but despite it’s small size I have managed to pack a lot in. The MSP430FR2433 has 15.5Kbytes of FRAM and 4Kbytes of SRAM. There are 3 communication ports UART & SPI, an external memory – either SRAM or FRAM and up to 4 x 10 bit ADC channels.
The external memory is either a 23K256 SRAM – and there’s facility for battery or super-cap backup, or a non-volatile FRAM device. Either way it extends the memory by a useful 32K to 256K bytes.
ChipStick comes with a detachable programmer section – which consists of the USB- serial converter IC and the 3V3 regulator. Without the programmer section ChipStick is just 27 x 11mm – and that’s small enough to fit inside a 2 x 4 LEGO block!
The programmer section is however fairly unobtrusive and can be kept in place – even when the device is plugged into a Launch Pad pcb.
- 07/21/16–10:39: A Perfect Storm
As such I am looking for alternatives – but for the meantime some recent posts will now be available here:
So long and thanks for all the fish…….