Arduino library for Nokia 5110 screen with complete buffer support

simLCD.cpp

#include "simLCD.h"

simLCD::simLCD()
{
	clear();
}

simLCD& simLCD::setSCLK(int pin)
{
	pinSCLK = pin;
	pinMode(pinSCLK, OUTPUT);
	return *this;
}

simLCD& simLCD::setSDIN(int pin)
{
	pinSDIN = pin;
	pinMode(pinSDIN, OUTPUT);
	return *this;
}

simLCD& simLCD::setDC(int pin)
{
	pinDC = pin;
	pinMode(pinDC, OUTPUT);
	return *this;
}

simLCD& simLCD::setRESET(int pin)
{
	pinRESET = pin;
	pinMode(pinRESET, OUTPUT);
	return *this;
}

simLCD& simLCD::setSCE(int pin)
{
	pinSCE = pin;
	pinMode(pinSCE, OUTPUT);
	return *this;
}

int simLCD::getSCLK()
{
	return pinSCLK;
}

int simLCD::getSDIN()
{
	return pinSDIN;
}

int simLCD::getDC()
{
	return pinDC;
}

int simLCD::getRESET()
{
	return pinRESET;
}

int simLCD::getSCE()
{
	return pinSCE;
}

simLCD& simLCD::reset()
{
	digitalWrite(pinRESET, LOW);
	digitalWrite(pinRESET, HIGH);
	write(LCD_C, 0x20);
	write(LCD_C, 0x0C);

	for (int i = 0; i < width * height / lineheight; i++) //clear the screen
		write(LCD_D, 0x00);

	return *this;
}

simLCD& simLCD::draw()
{
	for (int l = 0; l < height / lineheight; l++)
	{
		for (int x = 0; x < width; x++)
		{
			byte out = 0;
			for (int y = 0; y < lineheight; y++)
			{
				/*byte shift = 8 - x % 8 - 1;
				out |= buffer[l * lineheight + y][x / ELEMSIZE] & (1 << shift) >> shift << y;*/
				out |= bitRead(buffer[l * lineheight + y][x / ELEMSIZE], 8 - x % 8 - 1) << y;
			}
			write(LCD_D, out);
		}
	}
	return *this;
}

simLCD& simLCD::clear(boolean state)
{
	for (int y = 0; y < height; y++)
		for (int x = 0; x < CT_CEIL(width / ELEMSIZE); x++)
			buffer[y][x] = state ? 0b11111111 : 0b00000000;

	return *this;
}

simLCD& simLCD::drawpixel(int x, int y, boolean state)
{
	bitWrite(buffer[y][x / ELEMSIZE], 8 - x % 8 - 1, state);
	return *this;
}

simLCD& simLCD::drawline(int x1, int y1, int x2, int y2, boolean state)
{
	boolean steep = abs(y2 - y1) > abs(x2 - x1);
	if (steep)
	{
		swap(x1, y1);
		swap(x2, y2);
	}
	if (x1 > x2)
	{
		swap(x1, x2);
		swap(y1, y2);
	}

	int deltax = x2 - x1,
		deltay = abs(y2 - y1),
		error = deltax / 2,
		ystep,
		y = y1;
	if (y1 < y2)
		ystep = 1;
	else
		ystep = -1;

	for (int x = x1; x <= x2; x++)
	{
		if (steep)
			drawpixel(y, x, state);
		else
			drawpixel(x, y, state);

		error -= deltay;
		if (error < 0)
		{
			y += ystep;
			error += deltax;
		}
	}

	return *this;
}

simLCD& simLCD::drawcircle(int x0, int y0, int r, boolean state)
{
	int f = 1 - r,
		ddF_x = 1,
		ddF_y = -2 * r,
		x = 0,
		y = r;

	drawpixel(x0, y0 + r, state);
	drawpixel(x0, y0 - r, state);
	drawpixel(x0 + r, y0, state);
	drawpixel(x0 - r, y0, state);

	while(x < y)
	{
		if(f >= 0)
		{
			y--;
			ddF_y += 2;
			f += ddF_y;
		}
		x++;
		ddF_x += 2;
		f += ddF_x;
		drawpixel(x0 + x, y0 + y, state);
		drawpixel(x0 - x, y0 + y, state);
		drawpixel(x0 + x, y0 - y, state);
		drawpixel(x0 - x, y0 - y, state);
		drawpixel(x0 + y, y0 + x, state);
		drawpixel(x0 - y, y0 + x, state);
		drawpixel(x0 + y, y0 - x, state);
		drawpixel(x0 - y, y0 - x, state);
	}
	return *this;
}

simLCD& simLCD::drawstring(int x, int y, char* str, int spacer, boolean state)
{
	for (; *str; str++)
	{
		char c = *str;
		for (int col = 0; col < 5; col++)
		{
			for (int row = 0; row < 8; row++)
			{
				if (bitRead(ASCII[c - 0x20][col], row))
				{
					drawpixel(x + col, y + row, state);
				}
			}
		}
	}
}

void simLCD::write(byte dc, byte data)
{
	digitalWrite(pinDC, dc);
	digitalWrite(pinSCE, LOW);
	shiftOut(pinSDIN, pinSCLK, MSBFIRST, data);
	digitalWrite(pinSCE, HIGH);
}

void simLCD::swap(int& a, int& b)
{
	int t = a;
	a = b;
	b = t;
}

const byte simLCD::ASCII[][5] =
{
	{0x00, 0x00, 0x00, 0x00, 0x00}, // 20
	{0x00, 0x00, 0x5f, 0x00, 0x00}, // 21 !
	{0x00, 0x07, 0x00, 0x07, 0x00}, // 22 "
	{0x14, 0x7f, 0x14, 0x7f, 0x14}, // 23 #
	{0x24, 0x2a, 0x7f, 0x2a, 0x12}, // 24 $
	{0x23, 0x13, 0x08, 0x64, 0x62}, // 25 %
	{0x36, 0x49, 0x55, 0x22, 0x50}, // 26 &
	{0x00, 0x05, 0x03, 0x00, 0x00}, // 27 '
	{0x00, 0x1c, 0x22, 0x41, 0x00}, // 28 (
	{0x00, 0x41, 0x22, 0x1c, 0x00}, // 29 )
	{0x14, 0x08, 0x3e, 0x08, 0x14}, // 2a *
	{0x08, 0x08, 0x3e, 0x08, 0x08}, // 2b +
	{0x00, 0x50, 0x30, 0x00, 0x00}, // 2c ,
	{0x08, 0x08, 0x08, 0x08, 0x08}, // 2d -
	{0x00, 0x60, 0x60, 0x00, 0x00}, // 2e .
	{0x20, 0x10, 0x08, 0x04, 0x02}, // 2f /
	{0x3e, 0x51, 0x49, 0x45, 0x3e}, // 30 0
	{0x00, 0x42, 0x7f, 0x40, 0x00}, // 31 1
	{0x42, 0x61, 0x51, 0x49, 0x46}, // 32 2
	{0x21, 0x41, 0x45, 0x4b, 0x31}, // 33 3
	{0x18, 0x14, 0x12, 0x7f, 0x10}, // 34 4
	{0x27, 0x45, 0x45, 0x45, 0x39}, // 35 5
	{0x3c, 0x4a, 0x49, 0x49, 0x30}, // 36 6
	{0x01, 0x71, 0x09, 0x05, 0x03}, // 37 7
	{0x36, 0x49, 0x49, 0x49, 0x36}, // 38 8
	{0x06, 0x49, 0x49, 0x29, 0x1e}, // 39 9
	{0x00, 0x36, 0x36, 0x00, 0x00}, // 3a :
	{0x00, 0x56, 0x36, 0x00, 0x00}, // 3b ;
	{0x08, 0x14, 0x22, 0x41, 0x00}, // 3c <
	{0x14, 0x14, 0x14, 0x14, 0x14}, // 3d =
	{0x00, 0x41, 0x22, 0x14, 0x08}, // 3e >
	{0x02, 0x01, 0x51, 0x09, 0x06}, // 3f ?
	{0x32, 0x49, 0x79, 0x41, 0x3e}, // 40 @
	{0x7e, 0x11, 0x11, 0x11, 0x7e}, // 41 A
	{0x7f, 0x49, 0x49, 0x49, 0x36}, // 42 B
	{0x3e, 0x41, 0x41, 0x41, 0x22}, // 43 C
	{0x7f, 0x41, 0x41, 0x22, 0x1c}, // 44 D
	{0x7f, 0x49, 0x49, 0x49, 0x41}, // 45 E
	{0x7f, 0x09, 0x09, 0x09, 0x01}, // 46 F
	{0x3e, 0x41, 0x49, 0x49, 0x7a}, // 47 G
	{0x7f, 0x08, 0x08, 0x08, 0x7f}, // 48 H
	{0x00, 0x41, 0x7f, 0x41, 0x00}, // 49 I
	{0x20, 0x40, 0x41, 0x3f, 0x01}, // 4a J
	{0x7f, 0x08, 0x14, 0x22, 0x41}, // 4b K
	{0x7f, 0x40, 0x40, 0x40, 0x40}, // 4c L
	{0x7f, 0x02, 0x0c, 0x02, 0x7f}, // 4d M
	{0x7f, 0x04, 0x08, 0x10, 0x7f}, // 4e N
	{0x3e, 0x41, 0x41, 0x41, 0x3e}, // 4f O
	{0x7f, 0x09, 0x09, 0x09, 0x06}, // 50 P
	{0x3e, 0x41, 0x51, 0x21, 0x5e}, // 51 Q
	{0x7f, 0x09, 0x19, 0x29, 0x46}, // 52 R
	{0x46, 0x49, 0x49, 0x49, 0x31}, // 53 S
	{0x01, 0x01, 0x7f, 0x01, 0x01}, // 54 T
	{0x3f, 0x40, 0x40, 0x40, 0x3f}, // 55 U
	{0x1f, 0x20, 0x40, 0x20, 0x1f}, // 56 V
	{0x3f, 0x40, 0x38, 0x40, 0x3f}, // 57 W
	{0x63, 0x14, 0x08, 0x14, 0x63}, // 58 X
	{0x07, 0x08, 0x70, 0x08, 0x07}, // 59 Y
	{0x61, 0x51, 0x49, 0x45, 0x43}, // 5a Z
	{0x00, 0x7f, 0x41, 0x41, 0x00}, // 5b [
	{0x02, 0x04, 0x08, 0x10, 0x20}, // 5c \ COMMENT FIXED
	{0x00, 0x41, 0x41, 0x7f, 0x00}, // 5d ]
	{0x04, 0x02, 0x01, 0x02, 0x04}, // 5e ^
	{0x40, 0x40, 0x40, 0x40, 0x40}, // 5f _
	{0x00, 0x01, 0x02, 0x04, 0x00}, // 60 `
	{0x20, 0x54, 0x54, 0x54, 0x78}, // 61 a
	{0x7f, 0x48, 0x44, 0x44, 0x38}, // 62 b
	{0x38, 0x44, 0x44, 0x44, 0x20}, // 63 c
	{0x38, 0x44, 0x44, 0x48, 0x7f}, // 64 d
	{0x38, 0x54, 0x54, 0x54, 0x18}, // 65 e
	{0x08, 0x7e, 0x09, 0x01, 0x02}, // 66 f
	{0x0c, 0x52, 0x52, 0x52, 0x3e}, // 67 g
	{0x7f, 0x08, 0x04, 0x04, 0x78}, // 68 h
	{0x00, 0x44, 0x7d, 0x40, 0x00}, // 69 i
	{0x20, 0x40, 0x44, 0x3d, 0x00}, // 6a j
	{0x7f, 0x10, 0x28, 0x44, 0x00}, // 6b k
	{0x00, 0x41, 0x7f, 0x40, 0x00}, // 6c l
	{0x7c, 0x04, 0x18, 0x04, 0x78}, // 6d m
	{0x7c, 0x08, 0x04, 0x04, 0x78}, // 6e n
	{0x38, 0x44, 0x44, 0x44, 0x38}, // 6f o
	{0x7c, 0x14, 0x14, 0x14, 0x08}, // 70 p
	{0x08, 0x14, 0x14, 0x18, 0x7c}, // 71 q
	{0x7c, 0x08, 0x04, 0x04, 0x08}, // 72 r
	{0x48, 0x54, 0x54, 0x54, 0x20}, // 73 s
	{0x04, 0x3f, 0x44, 0x40, 0x20}, // 74 t
	{0x3c, 0x40, 0x40, 0x20, 0x7c}, // 75 u
	{0x1c, 0x20, 0x40, 0x20, 0x1c}, // 76 v
	{0x3c, 0x40, 0x30, 0x40, 0x3c}, // 77 w
	{0x44, 0x28, 0x10, 0x28, 0x44}, // 78 x
	{0x0c, 0x50, 0x50, 0x50, 0x3c}, // 79 y
	{0x44, 0x64, 0x54, 0x4c, 0x44}, // 7a z
	{0x00, 0x08, 0x36, 0x41, 0x00}, // 7b {
	{0x00, 0x00, 0x7f, 0x00, 0x00}, // 7c |
	{0x00, 0x41, 0x36, 0x08, 0x00}, // 7d }
	{0x10, 0x08, 0x08, 0x10, 0x08}, // 7e ~ COMMENT FIXED
	{0x78, 0x46, 0x41, 0x46, 0x78}  // 7f   WTF
};

simLCD.h

#ifndef SIMLCD_H
#define SIMLCD_H

#include "WProgram.h"

#define CT_CEIL(X) ((X - (int)X) == 0 ? (int)X : (int)X+1)
#define CT_FLOOR(X) ((int)X)

class simLCD
{
	public:
		static const int 	width = 84, //screen size
							height = 48,
							lineheight = 8;
		simLCD();
		
		//set pins
		simLCD& setSCLK(int);
		simLCD& setSDIN(int);
		simLCD& setDC(int);
		simLCD& setRESET(int);
		simLCD& setSCE(int);
		
		//get pins
		int getSCLK();
		int getSDIN();
		int getDC();
		int getRESET();
		int getSCE();
		
		//reset screen
		simLCD& reset();
		
		simLCD& draw();
		simLCD& clear(boolean = false);
		simLCD& drawpixel(int, int, boolean = true);
		simLCD& drawline(int, int, int, int, boolean = true);
		simLCD& drawcircle(int, int, int, boolean = true);
		simLCD& drawstring(int, int, char*, int, boolean = true);
	private:
		int pinSCLK, pinSDIN, pinDC, pinRESET, pinSCE; //pins
		static const int	LCD_C = LOW, //pinDC settings
							LCD_D = HIGH,
							ELEMSIZE = sizeof(byte) * 8; //buffer element size in bits
		
		byte buffer[height][CT_CEIL(width / ELEMSIZE)];
		
		void write(byte, byte); //write out byte of data
		
		void swap(int&, int&);

		static const byte ASCII[][5];
};
#endif