Review: 4D Systems Display Starter Kit (Arduino & Raspberry Pi) & Bezel

Note: This is quite a long posting, so feel free to bookmark it for future reference! It’s taken me quite a bit of effort to put together, so I hope you enjoy reading it and following along.

If you’re like me, you are probably someone who have made a few Arduino and Raspberry Pi projects from time to time and are very familiar with HD44780 character LCDs and push button shields as a form of interface to the user.

Character LCD Shields

In fact, you’re probably tired of the 16×2 character LCDs because they’re rather limited (in their number of characters and the things they can display), and you’re probably fairly tired of polling the buttons as well. If you wanted to do something graphical, there is the option of a Nokia LCD screen, but that’s still monochrome and limited in resolution. None of these options are particularly aesthetically appealing.

It’s at this point you realize that anything more sophisticated, say a colour graphics LCD, requires a lot more work. They require wide parallel interfaces and a display memory buffer, at a substantial clock rate, which are best handled by dedicated display driver hardware. The smaller microcontroller boards can’t really handle this on their own, and even then, you’d still need to code up some intelligence behind drawing bit-mapped letters or rasterizing lines and circles. Further to this, you would expect them to be pretty expensive as well.

Hold onto your hats … because this might just change your mind entirely.

4D Systems Offerings

4D Systems is an Australian company, headquartered in Sydney with manufacturing and regional office in Philippines, which produces intelligent graphic solutions based around OLED and LCD technologies with custom graphics processors. Their product portfolio is ever-expanding and centres around three of their graphic processors – Goldelox, Picaso and Diablo16. They are also beginning to provide accessories, such as cameras, sound modules and GPS units which can be integrated with the graphic solutions above or used with other development platforms. They retail directly to the customer and through a network of distributors at every level, from starter kits, to just the display module, down to the bare IC and bare LCD units for incorporation into a final design.

The Goldelox graphic processor is used in their smaller OLED displays, whereas the Diablo16 graphic processor is used in their largest LCD modules. The rest of the modules (at this time) use the Picaso processor which simplifies development by allowing easy (almost plug and unplug) interchange of larger and smaller LCD modules as required. The processor is the magic that allows for the screen to be controlled via a TTL serial port using either the Serial Command Set or the ViSi-Genie command set (or one you define yourself through native 4DGL code for the display’s controller).

At the present moment, these are the available Picaso based modules and their pricing.

Model             Resolution              Price
uLCD-24PTU        320x240                 US$ 59
uLCD-28PTU        320x240                 US$ 69
uLCD-32PTU        320x240                 US$ 79
uLCD-43(P/PT/PCT) 480x272                 US$ 99
uOLED-32028-P1T   320x240                 US$189
uVGA-III          320x240/640x480/800x480 US$ 59

The uLCD range feature LCD displays of 2.4″, 2.8″, 3.2″ and 4.3″ size (measured diagonally). The 4.3″ LCD is a wide-screen form factor, whereas the others are 4:3 with an identical resolution making interchange easy. The uOLED is an AMOLED display of 3.2″, and the uVGA-III is a graphics controller which provides a HD15 “VGA” port output for driving an external display at the listed resolutions, but is without touch capabilities.

There are also starter kits available for most modules.

Kit Type      Price
uLCD-24PTU-** US$ 65
uLCD-28PTU-** US$ 75
uLCD-32PTU-** US$ 85
uLCD-43PT-**  US$145
SK-24PTU-**   US$ 93
SK-28PTU-**   US$102
SK-32PTU-**   US$111
SK-43PT-**    US$165

PI-Raspberry Pi

The uLCD products ending with a two letter suffix of AR or PI are the Arduino or Raspberry Pi kits respectively. The kits include the display, the shield or adaptor to plug the display in, the 5-pin cable from the display to the adaptor, a 5-pin male to male adaptor plug and a quick start guide. This is enough to get started in the Serial environment (which the module will be pre-loaded with), but will not allow you to explore the Designer/ViSi/ViSi-Genie modes without buying the 4D Programming Adaptor and a microSD card at the least. In the case of the Arduino, you may need the 4D Programming Adaptor anyway to provide more power to the screen.

The SK products are full Starter Kits which additionally include the microSD card, and programming adapter. The screens in these kits are provided with a demo application which is also pre-loaded onto the microSD card. These items are also available individually (although they may not be configured for the demo application).

Item                      Price
4D Serial Pi Adaptor      US$ 9.00
4D Arduino Adaptor Shield US$ 9.00
uUSB-PA5                  US$20.00
uSD-2GB                   US$16.00
4D Bezel                  US$ 9.99

However, the 5-way cables don’t seem to be available separately on their website, nor the male-to-male adapter. Note that all prices are subject to change.

As you can see, there are a lot of options even just looking at display modules because of the way they offer their solutions at every level.

Getting started with the 4D Systems Displays is easiest with a Starter Kit (which I would recommend to first time users). Choose the starter kit that targets your chosen platform, and you can add an additional adaptor for another platform should you wish to develop for both Arduino and Raspberry Pi. Optionally, add on any other accessories which you might need.

When I was contacted by 4D Systems to review their products, I was honoured as well as surprised to see such things existed. The idea that the Arduino could drive a full colour graphics LCD at a reasonable cost is not dead after all! When I was asked which products I would choose for this review, I decided upon the following:

  • SK-32PTU-AR
  • 4D Serial Pi Adaptor
  • 4DBEZEL-32-B

The larger 3.2″ screen would provide ample room for touch buttons (so they aren’t too close together for comfort), and the addition of the Serial Pi adaptor allows me to use my display with the Arduino (as the starter kit targets the Arduino) and the Raspberry Pi as well. Finally, the addition of the Bezel provides a nice finishing touch when it comes time to mount the display.

I’d like to thank 4D Systems for providing the products for review.

Unboxing the Hardware

The items were all securely packed in several sturdy glossy cardboard boxes padded internally with foam. If you see fewer boxes than you expect, don’t panic, as the microSD has been inserted into the screen, and the programming adaptor has been placed inside the LCD module box as well to save space and protect it. Interestingly, the bezel was packed in a static shielding bag (it’s not ESD sensitive!).

4D Systems Items

4D uLCD-32PTU LCD Module

The largest box contains the actual LCD module, shipped with a protective film on top. You should remove this film using the green tab when you’re ready to put it in use, otherwise the protective film may cause a bit of haziness/reflection and show up some scratches.


The bottom corner of the front seems to be inscribed with BINGO 033201-A0 which may be a clue to the LCD or touch film manufacturer. The LCD itself is numbered 4DLCD-32Q-A, and is attached to the controller module on the rear.


The red PCB on the rear of the display module is what sets this apart from a “plain” graphics LCD. It contains the Picaso display controller, pins for power, I/O, and battery, a small speaker and a microSD card slot (with a card installed). The PCB is scored for their production use – it allows them to break off unused sections to fit the board to their smaller displays. The PCB is nicely coloured red to match the other 4D Systems products, and features useful silkscreen text which guides you in connecting to the pins, reducing the need to always refer back to the datasheet.

The display itself is connected to the controller PCB via the orange flexible ribbon pictured towards the bottom – you really should avoid touching, scratching, stretching or snagging this ribbon otherwise your display may malfunction. Inside the box, the Quick Start Guide, Programming Adaptor and the 5-way cable with Male-to-Male adaptor is also included.

The datasheet for the display module itself provides a tantalizing list of features including:

  • Picaso processor with Extensible Virtual Engine (EVE) architecture and support for 4DGL, ViSi-Genie, Serial Environment.
  • 3.2″ (240×320) LCD Screen with 65K colours and resistive touch panel.
  • 5-pin serial connection.
  • 14kB FLASH and 14kB SRAM.
  • microSD (FAT16, RAW) support.
  • Audio Amplifier and Speaker.
  • PWM Audio playback of WAV files.
  • Lithium-Ion/Lithium-Polymer battery support, auto-changeover and charger.
  • 13 GPIO Pins (including I2C and two asynchronous serial).
  • Top 8 GPIO pins can be used as 8-bit Bus for parallel data transfer operations.
  • 8 x 16 bit timers with 1ms resolution
  • 30-pin header for I/O expansion and future plug-in daughter boards.
  • 4.0v to 5.5v range operation, single supply.
  • Dimensions: 56.32mm x 79.69mm x 15.0mm including corner plates.
  • Weight: 50 grams.
  • Viewing Area 48.60mm x 64.80mm.
  • RoHS Compliant.

4D 2Gb microSD Card

DSC_2094As mentioned above, the microSD card came pre-installed in the slot.

The card itself is not branded (OEM type) and is Made in Taiwan. For those who are interested, the card data is:

CID: 035344534430324730daca2b3100d30d
CSD: 005e00325b5aa3b07fffff800a80001d

Out of interest, I performed a HDTune Pro read and a CrystalDiskMark benchmark on the card – it wasn’t anything particularly special to report.


You really don’t need any particularly high performance cards for this application, although highly reliable ones would be desirable. Because of the FAT16 support on board, it is really only able to utilize 2-4Gb with a file system. It is capable of accessing even larger SDHC cards but only on a raw sector basis.

Starter-Kit-SD-CardThe microSD card comes pre-loaded with files which are used for starter kit demonstration purposes. It is used during development to hold the files required for Designer, ViSi and ViSi-Genie projects.

In order to load your own files from the 4D Workshop, you will need to supply your own microSD compatible card reader. It is not possible to load the files through the display for performance reasons (as the files can be quite large), and this takes a little patience and getting used to.

4D Programming Adaptor

4D Programming Adaptor Top 4D Programming Adaptor BottomAs could be seen above, the 4D Programming Adaptor is curiously supplied in a small plastic pouch that doesn’t appear to be static shielding. Regardless, it managed to arrive in working order, and is based around the FTDI FT232RQ IC, which is a commonly used USB to Serial chipset with good driver support. There is a single LED indicating the activity, and additional circuitry to drive the reset signal.

Some additional signals are broken out to pads which may be useful in the future. There is an edge mounted female five pin socket for the male-to-male adaptor to mate with, which then connects to the female socket of the 5-pin cables. In that configuration, the programming adaptor provides power and data connection to the LCD module to enable 4D Workshop IDE to program the Picaso processor (e.g. PmmC updates, loading program code) or to interact with it serially (e.g. Serial Commander for SPE mode, GTX for ViSi-Genie mode debugging).

No USB cable is included, the user must supply their own USB to miniUSB-B cable.

Arduino Adaptor Shield

4D Systems Arduino Shield

For Arduino users, this is their revision 2 shield which allows you to connect your display module to your Arduino. This shield may appear slightly confusing given the configurability and number of pins, but a quick consultation with the Arduino Shield Datasheet clears it up.

  • J1 is used to select the reset source – either from the Arduino (left position) or the Programming Cable (right position). For most users, this is probably better set to the Arduino.
  • J2 is used to select the power source – either from the Arduino (left position) or the Programming Cable (right position). As the Arduino when connected by USB may not be able to source enough power to reliably run the display, I would recommend it be set to the Programming Cable and have that attached to a second USB port.
  • J3 is used to select the RX line connection, either to D0 (left position) or D2 (right position).
  • J4 is used to select the TX line connection, either to D1 (left position) or D3 (right position).

The RX and TX line selection is provided as D0 and D1 are the hardware serial port for the Arduino and is used for programming the Arduino. If you choose to have your display connected to D0 and D1, you must unplug your display while reprogramming the Arduino or the programming will fail. By choosing D2 and D3, you can use SoftwareSerial to emulate a serial port on those pins and provide a connection that does not interfere with programming the Arduino.

But, there is a catch – SoftwareSerial will not operate on D2 and D3 on Mega, Mega2560 or Leonardo boards due to hardware constraints. The other issue is that SoftwareSerial is less reliable in general, especially at higher baud rates.

H1 is used for connecting to your display, and H2 is used to connect the programming cable for additional power only. Serial commands are not passed through!

4D Systems Arduino Shield UndersideThe design of the shield is rather sensible, with pass-through on all pins. Depending on your jumper selections, this shield makes use of pins D0, D1 (or D2, D3) and D4 (for reset, unless you’ve selected Programming Cable). This leaves the higher numbered pins free, which are more commonly used by other shields. A very sensible design choice. There is also a reset button placed on the shield which allows you to reset the Arduino – it is not used to reset the display module.

There isn’t anything to report on the underside.

4D Systems Arduino Shield Pins

I have been informed that this particular shield is a pre-production unit, and those which are shipped to consumers will be built to a higher standard. It still makes sense to take extra care when inserting and removing it from your Arduino to avoid damaging the pins! When using the hardware serial port, in order to reprogram your Arduino, you can just remove the cable from the shield to the display module – there’s no need to remove the entire shield.

Raspberry Pi Serial Adaptor

4D Raspberry Pi Serial Adaptor Top 4D Raspberry Pi Serial Adaptor Bottom

The 4D Raspberry Pi Serial Adaptor is a very simple board which connects the 5V, RX and TX data lines while leaving the Reset line unconnected. The adaptor itself is intelligently designed as its output pins are at right angles allowing the cable to “snake out” while having a pass-through of all the pins on the Raspberry Pi’s GPIO header allowing you to still connect other I/O boards to the GPIO header. This is important for more sophisticated Raspberry Pi projects, however, the boards that rely on the ports of the Raspberry Pi for mechanical support will need to be supported through other means (e.g. standoffs). The package includes another 5-way cable and male-to-male adaptor, not that the male to male adaptor is strictly necessary as the Serial-Pi Adaptor and the LCD display both feature male pins.

4D Bezel 32-B

4D Display in BezelThe availability of the bezels seems to vary for the models, but they are available in black or white. They seem to be well made and feel rigid as if adding support to the LCD module itself. It does add to the aesthetics by keeping the edges out of view, but is not waterproof so keep that in mind (the module definitely is not).

The LCD is secured to the bezel by four included small screws and washers, and the bezel itself can be fastened to your enclosure by using the included springy-clips, screws and washers. All you need to do is make an appropriate sized rectangular cut-out in your enclosure.



4D Picaso in Bezel

4D Bezel Washers

Unfortunately, they have only supplied the exact number of screws and washers so be very careful otherwise you might lose them – they’re tiny! It’s a great way to add the finishing touch to your project.

Applying Power

After unpacking all the items, I decided to plug the display into the Programming Adaptor and plug that into a USB port. Immediately, the drivers installed (as they are a common FTDI chip, same as used by many other devices) but the screen booted up into a rather impressive 4D Demo Application which showed colour background images, text, button, sound and video capabilities. It was all very impressive, although the sound was slightly on the quiet side with some hiss (possibly due to the PWM technique used to generate the audio). Unfortunately, I didn’t take any photos of this because I was so interested in getting my feet wet with the IDE. Once you start loading things onto the board, the demo is erased.

4D Workshop IDE

The other half of the equation is the 4D Workshop Integrated Development Environment (IDE). This software is provided free and allows the user to work with their LCD module and load programs via the Programming Adaptor in one of four modes – Designer, ViSi, ViSi-Genie and Serial. It also allows the user to access tools which are useful for debugging, updating and working with microSD cards (Serial Commander, Genie Test Executor, PmmC Updater, SD Card Partitioning).

At the moment, this software is only available for Windows, which is unfortunate for users of other operating systems, especially because the device-access nature of the program makes it unlikely to work correctly in Wine under Linux.


For those who have purchased a Starter Kit, installing the 4D Workshop IDE is practically mandatory as the modules shipped with the starter kit have been configured to run a demo application. As a result, they seem to carry outdated firmware (PmmC) and are not in the Serial Environment (as you would expect to use initially with your Arduino).

Luckily, 4D Workshop is easily downloaded from the 4D Systems website (no need for registration) and seems to be frequently updated for bug fixes and feature enhancements. The version used for the review was version It feels as if the software is pretty good, but is still not fully polished with the occasional glitch here or there.

crashedIt seems that small things like data validation haven’t been fully sorted out – entering a negative number in a field where it was not expected resulted in a crash …

spelling-errors… there are also little occasional spelling mistakes – for example, in this caption where millisecond is misspelled, and the wrong ‘by’ is used.

caption-bubbles-incorrectIn this case, the caption bubble itself which appears when hovering over a menu item is just filled with ‘x’es.

Of course, I am definitely not perfect, and all of these minor imperfections are perfectly forgiveable as they are merely cosmetic. Functionality wise, 4D Workshop IDE is top notch.

PmmC Update

The first thing you may be interested in doing is to update the Personality-module-micro-Code (PmmC) on the module. This is the firmware that controls the low-level operation of the display’s Picaso controller. In order to do this, you must connect the display to your computer using the 4D Programming Adaptor – using any other adaptor can cause damage to your module and void your warranty!

You will find that you need to perform the PmmC update when you try to put the module into Serial Mode by opening 4D Workshop and creating a new Serial Project like the below images shows. Not updating the PmmC to match the 4D Workshop version can cause mysterious errors, so make sure you do this!





Upon checking the Comms tab, you will see the following:


You can perform the PmmC update via the Tools tab – it’s a simple process of following the prompts. Then you can return to load the Serial Environment using the SPE Load button.




SPE Load


SPE SplashNow, all you have to do is return to the Tools tab and click on the SPE Load button. Once the loading completes, and after a short timeout, you will be greeted by the SPE splash screen which only is shown when there is no serial activity for about six seconds.

As you can see, everything is easily accomplished – it’s a case of ‘simply follow the prompts’. Now, our module is prepared for use with the Serial Environment libraries.

If you would like to test the Serial Environment commands, you can use the Serial Commander which provides you an easy way to submit commands to your display via the Programming Adaptor and view the result.


For example, in the above, I was setting the colour to change to Red, Green, Blue, then Black to test the screen for bad pixels and I’m delighted to report there were none (although, up to four is considered acceptable).

Touch-Screen Calibration

Touch Calibration 1A legacy of the resistive touch film system is the need to calibrate the screen to get accurate touch presses. This is easily accomplished by invoking the Touch Calibration command which will load the calibration software to your display.

In order to perform tTouch Calibration Drawinghe calibration, you need to accurately press the centre of the target in the top left corner, followed by the bottom right corner. It will then memorize the values, and provide you the Touch Calibration Finishedopportunity to test the calibration by drawing over the screen. As you can see, my screen seems to be less sensitive in the film on the left side, but it’s not too bad. If you get the calibration wrong, you can retry it by re-invoking the command. Pressing on the exit dot finalizes the calibration.

Touching again exits the calibration utility and allows the module to reboot back into Serial Environment (SPE mode).


Serial Environment with Arduino

While I made a passing mention of the Serial Environment in the last part, I didn’t actually explain what it was, and why you might want to begin with it. The Serial Environment is a fully documented mode which allows the display module to be slaved with a microcontroller or other computer controlling it over the serial link.

The serial environment commands are all byte-coded sequences (the codings are shown in the PICASO Serial Command Set Reference Manual) which represent the operation (or function), and the oprands (or arguments). The screen responds only with an ACK or a NAK. The screen basically does everything you tell it to do … it’s as simple as that.

There are commands for writing text, drawing shapes, setting values of pixels, reading the touch screen, amongst many others. As a result, your host is responsible for all of the layout logic down to each drawing command, and polling the touch screen. This is both a (small) burden, but also an advantage, as the development only takes place on your host and the display module does not require a microSD card to function. You can also purchase the standalone module which will come pre-loaded with the SPE environment, thus developing and deploying these modules without a programming adaptor is possible when the serial environment is used.

It also provides a large amount of flexibility, as you are free to draw whatever you want to, although it can be performance limited due to the serial link (especially if you are trying to transfer a whole bitmapped image).

While the byte-sequences are well defined, they are not convenient to work with directly, which is why libraries have been developed and provided by 4D Systems to make it easier to work with. The Serial Command Set Reference Manual includes the library function names to refer to.

The GitHub repository for 4D Systems contains the latest version of all the available libraries. For the Arduino, there is a Picaso-Serial-Arduino-Library which can be used with Picaso modules in SPE mode, and there is also a ViSi-Genie-Arduino-Library for when you have configured your module with a ViSi-Genie project. You should probably grab both of them by clicking on the Download ZIP button on each of the library pages, but you will have to be careful as to how you unzip them. You should unzip them first, and move the Picaso_Serial_4DLib folder and genieArduino folder to your Arduino/Libraries folder like so:


There are also various demos available in the GitHub repository, which I wasn’t aware of until I had finished my own little programs – feel free to have a go at them as well.

The Arduino serial library has a single example file called bigdemo which illustrates almost every single command available. If you have the starter kit files still on your microSD card, the sound files are used by the demo as well and the card is used for testing the microSD commands so do leave that in the display.

Initially, having tried both the Arduino Uno and Mega2560 with the adapter shield and the cable to the screen, I was not able to get anything happening. I managed to load the program with the screen cable disconnected, plugged in the screen and rebooted the Arduino. After a while, the SPE splash screen came up, and the Arduino gave up, blinking the LED connected to Pin 13 as a sign the program had entered the error callback function.

I thought I might have misconfigured the jumpers, or had a bad wire, or screwed something up. The answer was a shortage of power! Upon measuring the voltage at the LCD module’s terminals, it measured an “unhealthy” 4.62v. I changed the jumper over to Programming Adaptor power, and plugged it into another USB port. Immediately, the screen came to life with the demo. It’s quite cool to watch it cycle through numerous tests. As a result, the connections now looked like this – please note that the pin order on H1 is the reverse of H2 – the 5v leads face towards the reset button. I had made the mistake of misconnecting the wires once – lucky there was no damage, but I recommend you double-check your connections before applying power! Note that this board was jumpered to the SoftwareSerial settings for the photo, I reverted back to the hardware serial configuration soon-after.

4D Arduino LCD Connection

4D Systems BigdemoThe next thing I wanted to do was to utilize SoftwareSerial and instead use pins D2 and D3 for the serial connection, thus freeing me of the need to keep unplugging and re-plugging the display during development.

The comments on bigdemo implied that the #define DisplaySerial Serial line should be changed to something like #define DisplaySerial SerialS but I had no luck with that. Seeing the future declarations made me realize that you should just comment out that line, and uncomment the lines that say #include <SoftwareSerial.h> and SoftwareSerial DisplaySerial(2,3);. Unfortunately, I found that this allowed the display to pass the first test (print its model number) but then it would sit there in error. Further development and trials seemed to imply SoftwareSerial was somehow less reliable, so I reverted to mostly using hardware serial port on D0 and D1.

The other reason to stick with the hardware serial port really depends on your board – Mega, Mega2560 and Leonardo boards are not capable of software serial on pins 2 or 3 due to hardware constraints, so for the Mega, you could try using a jumper wire from the centre pin to the second or third hardware serial ports or just live with the need to plug and unplug the display with each programming cycle.

Doing “something” with the Serial Environment

Initially, when looking at the code for bigdemo, it is both impressive in terms of the features demonstrated and yet somewhat daunting in terms of the amount of code involved. Having never worked with a 4D Systems display module before, it takes a little bit of time to pick and tease out the sections which are most important when using it as a basis for your own coding. The demo itself is a little lacking in comments in some areas, although the function names for the library are logically chosen and consistent which is great. Referencing the PICASO Serial Command Set Reference Manual helped immensely in understanding the graphics-related portions of the code.

Instead, I focused on trying to achieve some smaller (but ultimately useful) goals in order to illustrate just how simple it can be to get up and running. From there, you can slowly build up towards your final solution. That is the approach I often prefer when learning and coding up solutions – and I think it’s also the approach the Arduino’s inbuilt libraries try to take – by having numerous digestible examples which are obvious and building upon those.

If you wish, you can download all of the Arduino sketches for my basic examples as a ZIP file here.

Random Colour Text


This is the first thing I decided to code up for the 4D Systems module, and I called it _4dtextrandomposcol. It’s a program which writes a string with a random colour value to a random position on the screen, the result should be the one on the left. If you make a few edits, you can easily change the background to black, with the result on the right.

This is useful as a way to see just how colourful this LCD is, and as a demonstration of the fact that the LCD uses 16-bit colour values in 5-6-5 representation, as opposed to the 24-bit colour values (8-8-8) used by most other applications (e.g. graphic design, web design). As this is the first example, I will take a little time to go through what is being done.

//#include <SoftwareSerial.h>
//SoftwareSerial DisplaySerial(2,3); // Using Software Serial

#define DisplaySerial Serial // Using Hardware Serial

#include "Picaso_Serial_4DLib.h"
#include "Picaso_Const4D.h"

Picaso_Serial_4DLib Display(&DisplaySerial);
unsigned long colourvalue = 0;
char tempstring[256] = {0}; // Temporary String Variable for putstr

void setup() {
  pinMode(4, OUTPUT);  // Set D4 on Arduino to Output (4D Arduino Adaptor V2 - Display Reset)
  digitalWrite(4, 1);  // Reset the Display via D4
  digitalWrite(4, 0);  // unReset the Display via D4  
  delay (3500); //let the display start up

  DisplaySerial.begin(9600); // Using default 9600 baud rate
  Display.TimeLimit4D = 5000 ; // 5 second timeout on all commands
  Display.gfx_BGcolour(WHITE); // Make it text on white background
  Display.gfx_ScreenMode(4); // Landscape, microSD Card Facing Up  
  Display.gfx_Cls(); // Clear Screen

void loop() {
  sprintf(tempstring,"Colour value 0x%04X\n",colourvalue); // Assemble colour value string into tempstring for putstr

The dissection of how the program works is as follows:

Initial Lines

  • The first two lines are commented out with // – these lines are for when the jumpering on the Arduino Shield is set for D2 and D3 “SoftwareSerial” use. If you uncomment these two lines, and comment out #define DisplaySerial Serial then your program will switch over to using SoftwareSerial.
  • #include “Picaso_Serial_4DLib.h” and #include “Picaso_Const4D.h” add the library files in for use, so you can use the library functions, and add many useful defined values for use with these functions. You should really take a look at the Picaso_Const4D.h file in the libraries folder to learn more about these values.
  • The display device itself is of Picaso_Serial_4DLib type, and is declared with the name Display in the line Picaso_Serial_4DLib Display(&DisplaySerial); which allows us to access the display’s methods/functions by calling Display.something
  • I declare and initialize some variables for use – colourvalue for holding the colour value, and tempstring to hold the sprintf output string for passing into Display.putstr (to draw it onto the screen).

Setup Function

  • The setup function is called once by the Arduino environment at the beginning of execution.
  • The first five lines are used to reset the display module and give it time to start up. This is necessary to ensure that the display responds correctly to commands (otherwise, it may miss or fail to execute some initial commands if the necessary wait period is not provided).
  • The link to the display is readied for use by DisplaySerial.begin(9600); which assumes your display is at its default baud rate configuration of 9600 bps.
  • Display.TimeLimit4D = 5000; sets the command timeout for the screen to 5 seconds. This may not seem necessary at first, but without it, touch commands do not perform at all.
  • Display.gfxBGcolour(WHITE); sets the display background colour to white. Note that a lot of colours are predefined inside the Picaso_Const4D.h file, so do take a look. Analogously, the following line set the text background colour to White.
  • Display.gfx_ScreenMode(4); sets the display orientation to Landscape with the microSD card facing upward. This is my preferred orientation as it rests on a flat surface, propped up by the programming connector. All four orientations are catered for.
  • Display.gfx_Cls(); clears the screen ready for drawing. This fills in the screen with the BGcolour. It’s easy to make the screen toggle between solid colours by alternately calling Display.gfxBGcolour(colour); and Display.gfx_Cls(); (so you can code up a bad pixel checker if you’d like).

Loop Function

  • The loop function is executed continuously in a loop by the Arduino.
  • Display.gfx_MoveTo(random(0,320),random(0,240)); sets the display to move the place where the next element will be drawn to a random x value between 0-319 and random y value between 0-239. Note that Arduino’s random function is exclusive for the maximum value.
  • colourvalue gets a random value from 0-65535 (the full 16-bit colour range), which is then used to set the text foreground colour with Display.txt_FGcolour(colourvalue);
  • The text string is assembled using sprintf to the temporary location tempstring in the format of “Colour Value 0x%04X\n” which results in what you see in the animated GIFs above.
  • This temporary string is actually written to the display by calling Display.putstr(tempstring);
  • We repeat this over and over … and over.

Hopefully that has helped you to follow along with what is happening – after looking at bigdemo and comparing it with this – it’s not so scary anymore! Note that I have stripped it to the bare essentials – you might also want to set the error callback function like bigdemo does as well, but is not

Random Colour Boxes

colour-rand-boxes This program is very similar to the previous program, and is called _4dboxrandomposcol. It draws 10×10 pixel boxes filled with a random colour at a random position on the screen.




You can see that this uses the Display.gfx_RectangleFilled(x1,y1,x2,y2,colour) function in conjunction with values returned by random(min,max). You can always replace the function with another to get triangles, circles, both filled and not-filled.

//#include <SoftwareSerial.h>
//SoftwareSerial DisplaySerial(2,3); // Using Software Serial

#define DisplaySerial Serial // Using Hardware Serial

#include "Picaso_Serial_4DLib.h"
#include "Picaso_Const4D.h"

Picaso_Serial_4DLib Display(&DisplaySerial);
unsigned long colourvalue = 0;
int randomx = 0;
int randomy = 0;

void setup() {
  pinMode(4, OUTPUT);  // Set D4 on Arduino to Output (4D Arduino Adaptor V2 - Display Reset)
  digitalWrite(4, 1);  // Reset the Display via D4
  digitalWrite(4, 0);  // unReset the Display via D4  
  delay (3500); //let the display start up

  DisplaySerial.begin(9600); // Using default 9600 baud rate
  Display.TimeLimit4D = 5000 ; // 5 second timeout on all commands  
  Display.gfx_BGcolour(WHITE); // Make it text on white background
  Display.gfx_ScreenMode(4); // Landscape, microSD Card Facing Up  
  Display.gfx_Cls(); // Clear Screen

void loop() {
  randomx = random(0,320);
  randomy = random(0,240);
  Display.gfx_RectangleFilled(randomx,randomy,randomx+10,randomy+10,colourvalue); // Make 10x10px boxes of colourvalue at random positions

Touch Screen Position Test

position-test-arduinoThis example is called _4dtouchco_ordinates and its job is to detect your touch and print the co-ordinates (X and Y) of the touch to the screen. It should look like this when running.



Note that you may be able to put the Display.touch_Set(TOUCH_ENABLE); and Display.touch_Set(TOUCH_REGIONDEFAULT); lines in the setup function rather than in the loop for an even tighter loop.

//#include <SoftwareSerial.h>
//SoftwareSerial DisplaySerial(2,3); // Using Software Serial

#define DisplaySerial Serial // Using Hardware Serial

#include "Picaso_Serial_4DLib.h"
#include "Picaso_Const4D.h"

Picaso_Serial_4DLib Display(&DisplaySerial);
unsigned long colourvalue = 0;
int xcoord = 0;
int ycoord = 0;
char tempstring[40] = {0}; // Temporary String Variable for putstr

void setup() {
  pinMode(4, OUTPUT);  // Set D4 on Arduino to Output (4D Arduino Adaptor V2 - Display Reset)
  digitalWrite(4, 1);  // Reset the Display via D4
  digitalWrite(4, 0);  // unReset the Display via D4  
  delay (3500); //let the display start up

  DisplaySerial.begin(9600); // Using default 9600 baud rate
  Display.TimeLimit4D = 5000 ; // 5 second timeout on all commands
  Display.gfx_BGcolour(WHITE); // Make it text on white background
  Display.gfx_ScreenMode(4); // Landscape, microSD Card Facing Up  
  Display.gfx_Cls(); // Clear Screen  

void loop() {
  sprintf(tempstring,"Touch at X: %03d Y: %03d",xcoord,ycoord);
  while (Display.touch_Get(TOUCH_STATUS) == NOTOUCH) {
  xcoord = Display.touch_Get(TOUCH_GETX);
  ycoord = Display.touch_Get(TOUCH_GETY);

In order to use the touch screen functionality, you must execute Display.touch_set(TOUCH_ENABLE); to enable the touch screen, and then set the area – by choosing TOUCH_REGIONDEFAULT, you can detect touches on the whole area of the screen. If you want to detect touches within a limited area, you can instead replace Display.touch_Set(TOUCH_REGIONDEFAULT); with Display.touch_DetectRegion(x1,y1,x2,y2); where (x1,y1) represent the top left co-ordinate, and (x2,y2) represent the bottom right co-ordinate.

The Display.touch_Get(TOUCH_STATUS) function is used to determine if there is a touch on the screen. It can be either one of NOTOUCH, TOUCH_PRESSED or TOUCH_MOVING. The X and Y co-ordinates can be retrieved with Display.touch_Get(TOUCH_GETX) and Display.touch_Get(TOUCH_GETY) respectively.

With those short examples in mind, we have demonstrated text, graphics and touch – it’s very easy to build upon the bare essentials to get even more sophisticated results. Almost anything is possible, although you might run out of space on your microcontroller or experience drawing delays due to the level of sophistication of your interface.

Speeding it Up

Depending on how complex your set of drawing commands are, it is conceivable that the serial link could be a bottleneck. By default, the default baud rate is set at 9600bps which is a “safe” and compatible speed, however, the baud rate can be changed by your program on-the-fly (as per the bigdemo example). You will probably find that rates up to 115200bps are generally reliable on hardware serial ports.

You can change the default baud rate for the serial environment by going to the Tools section of 4D Workshop and selecting the Serial tab where you can apply a new default baud rate. Then, you should reload the serial environment onto your board through the programming adaptor.


Serial Environment with Raspberry Pi

The serial environment has proved itself to be quite powerful, allowing you to perform drawing operations by sending commands to the module. Unfortunately, while there is a Serial Library for C available, the library itself is written for lcc compiler for Windows.

As a result, the library needs porting to make it workable under gcc in Linux, as it currently does not build. Unfortunately, my experience does not extend as far as this at the present time – but a few identified issues include the file name case (all capitals on GitHub, but expecting “mixed” case), use of Windows-specific libraries, and the use of Windows-specific datatypes (e.g. WORD).

As a result, I wasn’t able to get the Serial Environment working with the Raspberry Pi through the library. It should be possible to write your own C program utilizing the raw commands from the PICASO Serial Command Set Reference Manual but it’s going to require more effort.

Instead, if you are working with the Raspberry Pi, the ViSi-Genie mode is easier to work with, and might be enough for you!

ViSi-Genie with Arduino

A particular specialty of the 4D Systems design environment is the ViSi-Genie mode. While it also operates over the serial link, its protocol is structured differently (detailed in the ViSi Genie Reference Manual). The Genie mode uses specially constructed frames including error checking. It is a sort of “message passing” system which operates on the host and the display module.

In order to work with the ViSi-Genie system, you should concurrently design the user interface with your host system code by working with a graphical editor to add certain elements to your virtual screen, each of which is given a unique index number. You can then assign actions (onChanging, onChanged) to your elements as well, which can include changing forms, meters or reporting a message to the system. Once your design is complete, you can build it and load it to the screen and microSD card which will allow the screen to present the interface as designed.

When operating, the host can transmit frames which can be used to query (poll) the status of an element on the screen (of a certain type) with a given index number, or to write a value or string to an element of a certain type with a given index number. Likewise, the screen can also transmit frames which informs the host that a certain action has happened – e.g. a button has been pushed.

This takes the responsibility of drawing the screen away from the host, and reduces the link to passing these frames. It’s quite neat to see that you don’t have to poll the buttons if you design your project to take advantage of the onChanged event to notify the host.

One of the disadvantages of this mode is the requirement for the microSD card, and a need for the programming adaptor to write the program to the screen. Concurrent development of the interface with host software is a necessity which can result in some back-and-forth as both interface and host software evolve together.

Making a ViSi-Genie Project

Creating the ViSi-Genie project is as simple as following the prompts – also note that if you click on the LCD in the “Choose Your Product” screen, you can rotate the project for landscape display.

Rotate LCD

A ViSi-Genie project starts up with a single Form (you can think of this as a “page”), without any elements added. The visual representation of the screen is used along with the Object Inspector to build the ViSi-Genie design – no coding is required, merely a few changes to parameters.


Adding a button, for example, is as simple as selecting a button from the toolbar, and clicking in the screen area to add it. Then you can drag it around, resize it with the drag handles, and change its properties with the Object Inspector. You merely need to repeat this to add all the elements you need to your project, with each element receiving a serially indexed number (which you will need when coding up the program for your host).


That’s all that was needed to create the project below which was used with the Raspberry Pi ViSi-Genie library in the next chapter.


The element properties are listed in the Object Inspector, and values can be changed to customize some of the elements (for example, button colour, gauge scales, gauge ranges). The Events tab is used to allocate what happens when the element is triggered (onChanged, on Changing) and is the way you can chain events together so that changes to a slider can change an LED display without the host’s interaction for example.

You can also develop multiple virtual screens by adding more Forms to your project, and allocate buttons that will change Forms. This provides massive flexibility to change button layouts and add more buttons than would fit on a page.

Once the project has fully been developed, it can be saved and then built. It will ask you to provide the drive letter for the microSD card so it can load the required resources to the card (as it cannot be done through the serial link due to performance reasons).


Once it has copied the files to the card, it will also load a program onto the display module. You will need to insert the card into the display module before it will start into the ViSi-Genie layout.

Debugging a ViSi-Genie Project

Under the Tools tab, there is a button labeled GTX which stands for Genie Test eXecutor. This allows you to test and debug the functionality of your ViSi-Genie design when connected through the programing adaptor. You can interact with the screen and see the data received from the screen, and you can execute queries of the buttons using the tool.


There is also an option to ZIP the project up for ease of e-mailing or transferring the files.

Preparing the Arduino

If you followed my suggestion in the Serial Environment with Arduino chapter, you would have already downloaded and set-up the ViSi-Genie-Arduino-Library from 4D System’s github repository. If not, you will need to download it and unzip it into the Arduino\Libraries folder.

arduino-metronomeThe example I have coded is a simple simulated metronome, called _4dgenietrial which is within the same Arduino Sketches zip file here. As the ViSi-Genie projects are concurrently developed, the example I will present below also requires file which contains the ViSi-Genie project.

The project will look something like the animated GIF on the left. Sorry for the shakiness!

The ViSi-Genie project has four 4Dbutton objects – Start is index 1, Stop is 0, Speed+ is 2, Speed- is 3, all of which send a message to the host. The index was determined by the order I added the buttons to the project. It also has an LED display index 0 and a meter index 0.

The code in the Arduino sketch is:

#include <genieArduino.h>

int bpmval=0;
int bpmchanged=1;
int running=0;
unsigned long ctime=0;
int outval=0;
int gaugeVal=0;
unsigned long timeinterval=0;
int swingdir=1;

void setup() 
  genieBegin (GENIE_SERIAL,9600);  //Serial0

  pinMode(4, OUTPUT);  // Set D4 on Arduino to Output (4D Arduino Adaptor V2 - Display Reset)
  digitalWrite(4, 1);  // Reset the Display via D4
  digitalWrite(4, 0);  // unReset the Display via D4

  delay (3500); //let the display start up

void loop() 
  if(running) {
    if(swingdir) {
    } else {
    genieWriteObject(GENIE_OBJ_METER, 0x00, gaugeVal);     
      outval = !outval;
      swingdir = !swingdir;

void EventHandler(void) {
  genieFrame Event;

  //If the cmd received is from a Reported Event
  if(Event.reportObject.cmd == GENIE_REPORT_EVENT) {
    if (Event.reportObject.object == GENIE_OBJ_4DBUTTON) {
      if (Event.reportObject.index == 1) {
        // Start Button
      } else if (Event.reportObject.index == 0) {
        // Stop Button
      } else if (Event.reportObject.index == 2) {
        // BPM Increase Button
      } else if (Event.reportObject.index == 3) {
        // BPM Decrease Button

  if(bpmchanged) {        
    genieWriteObject(GENIE_OBJ_LED_DIGITS, 0x00, bpmval);     // Write Slider0 value to to LED Digits 0 

The breakdown of how the program works is as follows:

  • #include <genieArduino.h> is needed to access the functions and definitions in the ViSi-Genie Arduino library.
  • Many temporary variables are declared.
  • The setup function starts up the hardware serial port at 9600bps (default speed) for ViSi-Genie library use by genieBegin (GENIE_SERIAL,9600);
  • In order to set a function which is called when a genie event occurs, we call genieAttachEventHandler(EventHandler); to attach a function called EventHandler to be executed when a genie event occurs.
  • The display is then reset, and given a delay so that it can start-up.
  • The loop function contains genieDoEvents(); which needs to be called periodically (preferably frequently) which is a library function which checks for serial port messages, does the required decoding of events. If an event happens, EventHandler is called.
  • The rest of the main checks if the metronome is running, and produces the values to be written to the meter to make it ‘swing’.
  • The EventHandler function is where you will be placing code that handles what each event does. The event type is returned by Event.reportObject.cmd, I have only focused on reported events – reading genieArduino.h for the full list of definitions would be advised. The object type is returned by Event.reportObject.object, I have only focused on 4D Buttons (as that’s the only thing used in my project). Then it filters down to the index number of the button, which is returned by Event.reportObject.index.

Note that it doesn’t seem like the genieArduino library works with SoftwareSerial – I did try passing a pointer to a SoftwareSerial object but it didn’t work. Notice how the project has no commands about drawing objects? That’s part of the beauty of ViSi-Genie.

For what it does, it’s an impressively small amount of code required. The majority of the legwork is hidden away in the ViSi-Genie Arduino library which is provided for you. You just have to remind yourself of how your ViSi-Genie layout on the LCD will correspond to how your host will action on those elements (e.g. 4D button 1 is on, 0 is off, 3 is decrement, 2 is increment).

The beauty of ViSi-Genie is that elegant buttons, meters and sliders are all available with no coding effort required. The elements are referred to by their type and serial index, and the message parsing, construction, sending and receiving are all handled by the library (with error checking robustness), leaving you to focus on your program. With ViSi-Genie, it is even possible to have elements on the display which interact with other elements in the display in a command chain (using onChanging/onChanged) without the involvement of the main host, and it is also possible to have elements on the display which inform the host whenever they have something to report (so that there’s no need to waste time polling them continuously). It’s also possible to have multiple forms which are multiple layouts which can be toggled between on host command or by buttons laid out on the screen. It’s almost as if I’m dreaming – it’s marvellous stuff.

Speeding it Up

Similarly to the Serial Environment as discussed earlier, the baud rate for ViSi-Genie projects can be increased to reduce bottlenecks due to the serial interface (where your other hardware is capable of it). This can also be accessed through the Tools option in 4D Workshop under the Genie tab.


ViSi-Genie with Raspberry Pi

Making a ViSi-Genie application with the Raspberry Pi is the same when it comes to working with 4D Workshop IDE (as above), however, you will need to get and install the Raspberry Pi ViSi-Genie C library.

The library is called ViSi-Genie-RaspPi-Library. If you have a Raspberry Pi handy, fire up the terminal and put in

git clone

This will clone the library to a subfolder called ViSi-Genie-RaspPi-Library. Then you can build it by

cd ViSi-Genie-RaspPi-Library
sudo make install
sudo ldconfig

The last command updates the library links to ensure that compilation succeeds when references are made to the library.

A few more steps are necessary, to avoid the serial port from being used by the Raspberry Pi, otherwise your projects will fail to initialize the display. This involves modifying the /boot/cmdline.txt and /etc/inittab files. A simpler version of the instructions is in the file in the library folder.

button-press-testThe quick test application I decided to make is called geniepitest and is just to test six buttons and a strings “text” output, similar to the sort of I/O you get from a HD44870 character LCD shield.

The C source is here and the ViSi-Genie project is

In order to compile the C file, you need to execute

gcc -o geniepitest geniepitest.c -lgeniePi

This will compile the program to an executable which can be run by calling ./geniepitest

The program is as follows:

#include <stdio.h>
#include <unistd.h> // for usleep
#include <geniePi.h>


void handleEvent (struct genieReplyStruct *reply) {
  if(reply->object == GENIE_OBJ_4DBUTTON) {
    switch (reply->index) {
      case 0:
        genieWriteStr(0,"You pressed the RED button.");
      case 1:
        genieWriteStr(0,"You pressed the GREEN button.");
      case 2:
        genieWriteStr(0,"You pressed the BLUE button.");
      case 3:
        genieWriteStr(0,"You pressed the YELLOW button.");
      case 4:
        genieWriteStr(0,"You pressed the VIOLET button.");
      case 5:
        genieWriteStr(0,"You pressed the WHITE button.");

int main (int argc, char** argv) {
  struct genieReplyStruct reply;

  if(genieSetup("/dev/ttyAMA0",9600)<0) {
    printf("ViSi-Genie Failed to init display!\r\n");
    return(1); // Failed to initialize ViSi-Genie Display. Check Connections!

  while(1) {
    while(genieReplyAvail()) {
      usleep(20000); // wait 20ms between polls to save CPU


It seems that the ViSi-Genie library for Raspberry Pi may be a little older, as it doesn’t have the event number declaration for 4D buttons, hence why I added it to the beginning of the program. Note that these constants may change in the future. The structure is very similar to that used by the Arduino.

  • #include <geniePi.h> is needed to include the library functions and declarations.
  • genieSetup(“/dev/ttyAMA0”,9600) is used to start the display, the serial port is at /dev/ttyAMA0 on the Raspberry Pi. Negative return values are given when the display fails to initialize.
  • while(1) is equivalent to the “loop” function in Arduino, it runs in an endless loop. Instead, it constantly checks if there is a Genie reply available using genieReplyAvail(), and if so, the value is retrieved into reply (of type struct genieReplyStruct) using genieGetReply(&reply) and is passed into handleEvent(&reply).
  • The struct’s members object and index are used to determine what object of what index caused the event.
  • genieWriteStr(index,string) is used to update the text on the screen.

Of course, there are more functions in the geniePi library, but this covers some essential commands which should be enough to get going.

Designer and ViSi Modes

As I have been extremely busy with my study and other related activities, I haven’t had a chance to thoroughly explore the Designer and ViSi modes of operation. In fact, for those who are most interested in working with Arduino or Raspberry Pi, the Serial and ViSi-Genie modes are likely to be preferred and sufficient for those purposes.

The ViSi mode allows for a visual representation of the native 4DGL code as you are writing it. This allows you to write code which will actually run on the processor inside the display module. This allows you to better take advantage of the integrated peripherals and functions (timers, bus I/O, GPIO, Li-Ion battery monitoring, microSD raw and FAT access) which might allow for you to eschew any other CPU altogether. The one LCD module can be the heart of your embedded device – how exciting! Working with the LCD module in this way is eased by the 4D Development Board (4DevBoard) which breaks out the connections on the back and provides a prototyping area.

Pure-ViSi Mode

The Designer mode resembles much older-fashioned programming, which is used to write code directly without any visual aid. All of these can be used to further customize the results you get from the module.

With the high quality of documentation available (see 4DGL Programmers Reference Manual and PICASO 4DGL Internal Functions Reference Manual at this page), it would not be hard for someone unfamiliar with the functions and syntax to begin coding in 4DGL, although ensure you do take the time to thoroughly read the documentation to save yourself frustration. A nice feature is that the commands available in the Serial Environment and through the provided libraries are very similar to those used in native 4DGL.


4D Systems have done a great job with their intelligent LCD displays. The displays themselves are high quality, and their designs are robust. The range of displays available caters for a wide variety of needs and the development environment is provided without additional charge. The documentation for their products is excellent – it’s clear, it’s comprehensive, and it’s easy to read, and a variety of libraries are available for use which speeds up development. The development environment is first-class, being well laid out visually, fully featured and intuitive to use (although, at times, it can be a bit slow and is currently only available for Windows).

The motto of 4D Systems is “turning technology into art” and I really think they’ve done that. By providing an easy to use system, it is possible to retrofit an impressive user interface an existing project with minimal burden on the system and on the designer. The pricing is also quite sensible, especially so when the additional capabilities of the modules (Sound, Video, Lithium-Ion charger, parallel interface, GPIO, microSD card logging) are used.

For those who are truly bored of the limited character LCDs, or need something more flexible and aesthetically pleasing, this is an excellent input and output device to complement an existing platform. With the use of native 4DGL, you can even build a complete solution around the display module without any other platform involved. It is pleasing to see that solutions are provided at every level, should the future need arise to produce a solution en masse or even just to mount the LCD onto a box neatly.

In order to get the maximum benefit, it is imperative that you set aside a significant amount of time to understand the documentation provided. At times, the learning curve does feel steep as the provided examples are very sophisticated and aim to show off almost all the functions. Instead, simpler examples may be more useful to introduce users to each peripheral or method in isolation for easier “digestion”.

There is some frustration with developing for Arduino due to the shared use of the physical serial port between loading code for the AVR and for receiving/sending commands to the LCD. I found that SoftwareSerial was not a very reliable solution (and is not a solution at all for the Mega/Mega2560), and hence prototyping with the Arduino requires patience with plugging and unplugging cables. Further to this, the need for additional power (while unavoidable, due to the voltage drop through the Arduino prototyping board) might need to be better documented on product pages to ensure people ordering just the kit (not the whole Starter Kit) or are transitioning from another platform to the Arduino are aware that the problems they are having may not be code related at all.

The provision of a working Serial-C library for the Raspberry Pi would also be a great addition, opening up the ability for the serial command set to be used to its full potential with a more powerful host (than the Arduino). While the documentation is quite well written, some of the examples have inconsistent comments, and can be slightly difficult to understand.

In all, even with the ViSi-Genie mode alone, the module itself makes a great replacement for many input/output devices (buttons, character LCDs) and the use of a message-passing protocol allows for a button-polling-free experience which frees up the microcontroller. It also means no need to worry about the intricacies of debouncing switches as well. I really like the simple method of integration, although the need to develop a ViSi-Genie project in parallel with a microcontroller project, and load it to the display and microSD card separately only comes naturally after a few tries.

Looking at the documentation and examples, it is clear that 4D Systems works very hard to try and add new features, fix bugs and improve on what they have. By the time you read this review, chances are, some of the things may have been fixed and new products available.

It’s been a wonderful experience working with this particular module – I could have never thought that making a touch-interface on a graphics LCD could be made this easy. I’d like to thank 4D Systems for the opportunity to review their products, and for providing the products for my impartial and unbiased review.

About lui_gough

I'm a bit of a nut for electronics, computing, photography, radio, satellite and other technical hobbies. Click for more about me!
This entry was posted in Computing, Electronics, Raspberry Pi and tagged , , , , . Bookmark the permalink.

6 Responses to Review: 4D Systems Display Starter Kit (Arduino & Raspberry Pi) & Bezel

  1. Dorisvaldo B.Paiva says:

    Excellent !!, but I’m looking for Goldlox for uOled160-G1, Arduino mega get an error NAK = 0.
    Please any idea?

    • lui_gough says:

      Which mode are you trying to use it in? ViSi-Genie? Serial? Are you using the appropriate library for your mode?

      How have you got the jumpers on the Arduino Shield configured? Are you supplying extra power via the second header via the Programming Adaptor? Low voltage due to resistance through the Arduino board can make display modules behave erratically or not work altogether.

      Are you sure you have connected the 5-way cable to the correct set of pins?

      – Gough

      EDIT: Sorry, just realized you were referring to the Goldelox which has no ViSi-Genie, so I’m assuming you’re using Serial. Do you see the Serial Splash screen? Can you write a short program to clear screen and write some text and see what happens?

      You should use Hardware Serial on the Mega (i.e. D0, D1), load the program without the screen connected, and then connect the screen and reboot the Arduino. You will probably need to use external power though.

  2. Ron Rudokas says:

    Very nice review, thanx for all the work!
    Did you try operating stand alone (no other processor, simply running your application on the 4D board)?
    Looking at the resources on the display board it seems there would be no need to add the complexity of an Arduino or Rasberry board if your application will fit the available resources. Further I would expect net performance (screen update, touch performance) to improve dramatically with no serial interface. You did mention speed up re higher baud rates.
    Does it seem that there would be a performance advantage in running your entire application on the 4D board. (I’m looking at the 4D uLCD-70DT. Seems a perfect solution if you don’t need a ton of legacy stuff from Arduino or other systems).


    • lui_gough says:

      Dear Ron,

      I haven’t had the time to try it myself, predominantly because I’ve been working on many other things. It is indeed possible to make your application run on the board itself, and the capabilities are fairly decent, although you should note that you will have to learn how to use *yet another* environment, and the library support available is different (e.g. try getting Ethernet working on one of these boards – won’t be easy!). Also of note is that the I/O on this board is 3.3v, so for 5v TTL, there will need to be some level conversion.

      In reality, many users will feel more comfortable developing in a platform they already understand, to speed the process of development. In reality, unless you are using serial to draw very sophisticated layouts, the performance is quite acceptable. In ViSi-Genie, the screen has its resources stored on the uSD card, so its performance is even better as only the events have to traverse the serial link.

      However, if you feel comfortable and have the time to learn (there are very well documented manuals of the commands), then it would reduce system cost and complexity to develop everything in the one intelligent LCD rather than rely on both a host platform and the LCD.

      – Gough

      • Ron Rudokas says:

        Thanx for your quick and considered reply!
        I’ve done some execution time, power and cost critical work using the Atiny10, that needed to use assembly to meet the goals and I have the usual knowledge of C and Basic so there would be a learning curve no matter what. Getting the graphics extensions sorted out would be new also.
        Think I’ll just dive in and do it all on the LCD board, less hardware, less stuff to fail, smaller package, less power, slightly easier debug, etc.
        Seems a natural solution, I’m somewhat surprised I don’t see more activity with integrated boards (display, touch screen, processor). You almost always need a visual and a user input.

  3. Great Site
    Im having trouble getting my 32PTU to collect the temperature from my arduino board as there are so many reason why it wont work.
    I would be happy to send code an images so others may not stop there projects or give up
    I sincerely think the 4D system is right for so many projects
    If you can help this would be great

Error: Comment is Missing!