Philips PCF8833 on Pi
The Nokia 6100 display has been around for many years, but I picked one up on the cheap as they are now pretty much out of stock and selling cheaper than ever before.
I picked up a
Sparkfun version whilst buying some other components and thought I'd hook it up to my Pi for inclusion in some new projects. I could tell the display was old by the tarnishing on the connectors and a bit of cleaning was needed before the soldering iron came out.
The big issue is that you don't know if you'll get an Epson or Philips chip with the display. I believe that the Epson were included in older Sparkfun boards and Philips were later, but this is only reading between lines from various posts about the display.
Support for Raspberry Pi
There are various examples of implementations with the Pi on the Internet. Most of these are bit banged examples or some bizarre serial hack to work in 9bit mode. Most seem to report poor performance or complex arrangement of pins.
I downloaded one example to only get garbage on the screen and this was for a Philips.
In the end I decided to roll my own and create yet another example of working code for this display. My world is C/C++ but the examples can easily be converted to Python once the implementation is understood.
The old link for the Philips driver is now missing from Sparkfun, but I found it linked from
engpedrorafel's github site.
Writing 9 bit SPI to Raspberry Pi
The shield has been built for Arduino boards, hence the pin layout and extra pins which are not used.In addition to the physical layout the Arduino's can implement 9bit serial communications to the display. Try and do this with Linux on a Pi and it really doesn't want to work. This is due to the Linux spidev driver being limited and not supporting LoSSI protocol.
Deep down on the Broadcom 2835 it does support LoSSI but after some playing with the
BCM2835 library I only got as far as my code hanging and the SDA output doing nothing. I'm sure this can be made to work but in the meantime I hit on a better way to work using SPI using most drivers.
Writing with 8 bit SPI
Whilst looking at reasons why the Linux driver doesn't really support LoSSI there was a simple solution presented. Why not just use 9 bytes of data for transmission and use NOOP commands for empty bytes.
Despite the overhead of writing additional bytes, the advantage is still being able to use the SPI hardware to transfer the data and avoid too much unnecessary work in software (for instance bit banging data).
Bytes fit into the transmission as shown above. You actually only transmit 8 bytes of data and the 9th bit for D/C uses up the space for the 9th byte of data.
Example code
I wrote some example code using the BCM library. This has a wrapper which is good to go for C/C++. In hindsight a Python example with spidev may have been better and I may still provide one. WiringPi uses spidev but doesn't expose enough options from spidev to be useful.
The code below is very simple and sets up the display and then flashes red, green and blue screen fills as fast as possible. You should barely see the red and green fills in this code.
#include <stdio.h>
#include <stdint.h>
#include "bcm2835.h"
#define NOKIA_CMD 0
#define NOKIA_DTA 1
// global buffer
static char bitbuff[9] ;
static char prevByte ;
static int nCurByte ; // 0-8 value for 9 bytes
void writeSPI(int nDC, char byte)
{
char out = 0x00 ;
if (nCurByte == 0){ // First byte to write - exception as no prior byte
out = (byte >> (nCurByte+1));
}else{
out = (byte >> (nCurByte+1)) | (prevByte << (8-nCurByte)) ;
}
if (nDC == NOKIA_CMD){
out &= ~(1<<(7-nCurByte)) ;
}else{
out |= 1 << (7-nCurByte) ;
}
bitbuff[nCurByte] = out ;
prevByte = byte ;
// Fix the last byte and flush to spi
if (nCurByte >= 7){
// Last byte fits fully into the final 9th byte of buffer
bitbuff[8] = byte ;
bcm2835_spi_transfern(bitbuff, 9) ;
prevByte = 0x00 ;
nCurByte = 0 ; // reset counter, just flushed 9 bytes
}else{
// Next byte
nCurByte++ ;
}
}
void flushSPI(char noop)
{
// Add rest of bytes as NOOPS. Note Epson and Philips are different
while (nCurByte > 0){
writeSPI(NOKIA_CMD, noop) ;
}
}
void LCDClearScreen(uint8_t r, uint8_t g, uint8_t b)
{
uint8_t byteout = 0x00 ;
long i; // loop counter
long c; // colour counter
char clear_rgb[] = {0x00, 0x00, 0x00} ;
clear_rgb[0] = r;
clear_rgb[1] = g;
clear_rgb[2] = b;
// Row address set (command 0x2B)
writeSPI(NOKIA_CMD, 0x2B);
writeSPI(NOKIA_DTA, 0x00);
writeSPI(NOKIA_DTA, 131) ;
// Column address set (command 0x2A)
writeSPI(NOKIA_CMD, 0x2A);
writeSPI(NOKIA_DTA, 0x00);
writeSPI(NOKIA_DTA, 131) ;
// write to display memory over SPI
writeSPI(NOKIA_CMD, 0x2C); // RAMWR
c =0;
// 2 bytes per pixel for 12bit colours
for (i=0;i < 131 * 131 *2;i++){
byteout = 0x00 ;
byteout = clear_rgb[c] << 4 ;
c = c>=2?0:c+1 ;
byteout |= clear_rgb[c] & 0x0F ;
c = c>=2?0:c+1 ;
writeSPI(NOKIA_DTA,byteout);
}
}
void philips_init()
{
// SLEEPOUT - turn on booster circuits
writeSPI(NOKIA_CMD, 0x11);
// turn on booster voltage
writeSPI(NOKIA_CMD, 0x03) ;
// Inversion off
writeSPI(NOKIA_CMD, 0x20) ;
// Colour pixel format 12 bits
writeSPI(NOKIA_CMD, 0x3A) ;
writeSPI(NOKIA_DTA, 0x03) ;
// Set up memory access controller.
writeSPI(NOKIA_CMD, 0x36) ;
writeSPI(NOKIA_DTA, 0x10) ;
// Set contrast
writeSPI(NOKIA_CMD, 0x25) ;
writeSPI(NOKIA_DTA, 0x30) ;
bcm2835_delay(2000) ;
// display on
writeSPI(NOKIA_CMD, 0x29) ;
}
int main()
{
const uint8_t reset_pin = RPI_V2_GPIO_P1_22 ;
const char noop_cmd = 0x00 ;
if (bcm2835_init() <= 0){
fprintf(stderr, "Cannot initialise BCM library\n") ;
return -1 ;
}
// Setup the 9 byte buffer
nCurByte = 0 ;
prevByte = 0x00 ;
// Initialise the BCM library
bcm2835_spi_begin() ;
// Configure for CS0 or CS1
bcm2835_spi_chipSelect(BCM2835_SPI_CS0) ;
// Works with Mode 0
bcm2835_spi_setDataMode(BCM2835_SPI_MODE0) ;
// Nokia display sets CS on low
bcm2835_spi_setChipSelectPolarity(BCM2835_SPI_CS0, LOW) ;
// About 4 MHz when set to BCM2835_SPI_CLOCK_DIVIDER_64
// Successfully driven at around 15-16MHz
bcm2835_spi_setClockDivider(BCM2835_SPI_CLOCK_DIVIDER_64) ;
// Reset the display using pin
bcm2835_gpio_fsel(reset_pin, BCM2835_GPIO_FSEL_OUTP);
bcm2835_gpio_write(reset_pin, LOW) ;
bcm2835_delay(2000) ;
bcm2835_gpio_write(reset_pin, HIGH) ;
bcm2835_delay(2000) ;
// Only a demo for Philips PCF8833, but easy to reuse for Epson
philips_init() ;
flushSPI(noop_cmd) ;
// Update as quickly as possible
// Fill screen first with red then green then blue
LCDClearScreen(0x0F, 0x00, 0x00) ;
LCDClearScreen(0x00, 0x0F, 0x00) ;
LCDClearScreen(0x00, 0x00, 0x0F) ;
flushSPI(noop_cmd) ; // Flush any remaining bytes as NOOPs
// Close SPI session
bcm2835_spi_end() ;
bcm2835_close() ;
return 1 ;
}
