Merge branch 'master' of https://gitlab.cs.hs-fulda.de/fdai5253/roboter

5 years ago · 2e9dc216d4
20 changed files with 1546 additions and 0 deletions
--- a/Code/libraries/MX1508/LICENSE
+++ b/Code/libraries/MX1508/LICENSE
@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Cheng Saetern
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/Code/libraries/MX1508/MX1508.cpp
+++ b/Code/libraries/MX1508/MX1508.cpp
@ -0,0 +1,100 @@
+#include "MX1508.h"
+
+MX1508::MX1508( uint8_t pinIN1, uint8_t pinIN2) {
+  _pinIN1 = pinIN1; // always a PWM pin
+  _pinIN2 = pinIN2; // can be a non-Pwm pin.
+  _whichMode = FAST_DECAY;
+  _numPwmPins = PWM_2PIN;
+  pinMode(_pinIN1, OUTPUT);
+  pinMode(_pinIN2, OUTPUT);
+}
+
+MX1508::MX1508( uint8_t pinIN1, uint8_t pinIN2, DecayMode decayMode, NumOfPwmPins numPins) {
+  _pinIN1 = pinIN1; // always a PWM pin
+  _pinIN2 = pinIN2; // can be a non-Pwm pin.
+  _whichMode = decayMode;
+  _numPwmPins = numPins;
+  pinMode(_pinIN1, OUTPUT);
+  pinMode(_pinIN2, OUTPUT);
+}
+
+int MX1508::getPWM() {
+  return _pwmVal;
+}
+
+void MX1508::stopMotor() {
+  digitalWrite(_pinIN1, LOW);
+  digitalWrite(_pinIN2, LOW);
+}
+
+void MX1508::setResolution(unsigned int pwmResolution) {
+  _pwmResolution = pwmResolution;
+  if(_useAnalogWrite16) ICR1 = pwmResolution; 
+}
+
+void MX1508::setPWM16(uint8_t prescaler, unsigned int resolution){
+	if(prescaler > 5 || prescaler == 0) prescaler = 3; // default to 64 if not in range.
+	DDRB  |= _BV(PB1) | _BV(PB2);       /* set pin 9and 10 as outputs */
+    TCCR1A = _BV(COM1A1) | _BV(COM1B1) | _BV(WGM11);    // non-inverting PWM, mode 14 fastPWM, TOP =ICR1
+	TCCR1B = _BV(WGM13) | _BV(WGM12) | prescaler ;	// rescaler must be 1->5, 1,8,64,256,1028 respectively
+	ICR1 = resolution;
+	_pwmResolution = resolution;
+	_useAnalogWrite16 = true; 
+}
+
+void MX1508::analogWrite16(uint8_t pin, uint16_t val)
+{
+  if(_useAnalogWrite16){
+	if(val < 5) val =5;
+	switch (pin) {
+		case  9: OCR1A = val; break;
+		case 10: OCR1B = val; break;
+		default: analogWrite(pin,val);
+	} 
+  }else{
+	  analogWrite(pin, val);
+  }
+}
+
+void MX1508::motorGo(long pwmSpeed) {
+  _pwmVal = pwmSpeed;
+  if(pwmSpeed == 0) {
+	this->stopMotor();
+  } else {
+  // if set decay mode is set as fast decay mode
+  if (this->_whichMode == FAST_DECAY) {
+    if (pwmSpeed >= 0) {                        //forward fast decay
+      if(_numPwmPins == PWM_1PIN)digitalWrite(_pinIN2, LOW);
+	  else analogWrite16(_pinIN2, 1);
+      analogWrite16(_pinIN1, pwmSpeed);
+    } else if (this->_numPwmPins == PWM_2PIN) { // reverse fast decay
+      pwmSpeed *= -1;
+	  analogWrite16(_pinIN1, 1);
+      analogWrite16(_pinIN2, pwmSpeed);
+    } else if (this->_numPwmPins == PWM_1PIN) { // reverse slow decay
+      pwmSpeed *= -1;
+      pwmSpeed = map(pwmSpeed, 0, _pwmResolution, _pwmResolution, 0);
+      digitalWrite(_pinIN2, HIGH);
+      analogWrite16(_pinIN1, pwmSpeed);
+    }
+  } 
+   // if decay mode is set as slow decay mode
+  else {
+    if (pwmSpeed >= 0) {                        // forward slow decay
+      pwmSpeed = map(pwmSpeed, 0, _pwmResolution, _pwmResolution, 0);
+      if(_numPwmPins == PWM_1PIN)digitalWrite(_pinIN1, HIGH);
+	  else analogWrite16(_pinIN1, _pwmResolution);
+      analogWrite16(_pinIN2, pwmSpeed);
+    } else if (this->_numPwmPins == PWM_2PIN) { // reverse slow decay
+      pwmSpeed *= -1;
+      pwmSpeed = map(pwmSpeed, 0, _pwmResolution, _pwmResolution, 0);
+	  analogWrite16(_pinIN2, _pwmResolution);
+      analogWrite16(_pinIN1, pwmSpeed);
+    } else if (this->_numPwmPins == PWM_1PIN) { // reverse fast decay
+      pwmSpeed *= -1;
+      digitalWrite(_pinIN1, LOW);
+      analogWrite16(_pinIN2, pwmSpeed);
+    }
+  }
+}
+}
--- a/Code/libraries/MX1508/MX1508.h
+++ b/Code/libraries/MX1508/MX1508.h
@ -0,0 +1,39 @@
+#ifndef MX1508_h
+#define MX1508_h
+
+#include "Arduino.h"
+
+typedef enum
+{
+  FAST_DECAY  = 0,  // set non-PWM pin low
+  SLOW_DECAY = 1    // set non-PWM pin high
+} DecayMode;
+
+typedef enum
+{
+  PWM_1PIN  = 1,
+  PWM_2PIN  = 2
+} NumOfPwmPins;
+
+class MX1508 {
+  public:
+    MX1508(uint8_t pinIN1, uint8_t pinIN2); // default fast decay, 2 pwm pins
+    MX1508(uint8_t pinIN1, uint8_t pinIN2, DecayMode decayMode, NumOfPwmPins numPWM);
+    void motorGo(long pwmVal); // 
+    void setResolution(unsigned int resolution);
+    int getPWM();
+    void stopMotor(); 
+	void analogWrite16(uint8_t pin, uint16_t val);
+    void setPWM16(uint8_t prescaler, unsigned int resolution);
+  private:
+  
+    uint8_t _pinIN1;
+    uint8_t _pinIN2;
+	bool _useAnalogWrite16 = false;
+    int _pwmVal;
+    int _pwmResolution = 255;   //max resolution of pwm, default is 255.  
+    DecayMode _whichMode;
+    NumOfPwmPins _numPwmPins;
+};
+
+#endif
--- a/Code/libraries/MX1508/README.md
+++ b/Code/libraries/MX1508/README.md
@ -0,0 +1,4 @@
+# MX1508
+Arduino library for MX1508 dual DC motor driver
+
+This motor driver is only ideal for low power applications(Motors that draws less that 1.5A). 
--- a/Code/libraries/MX1508/examples/16bitResolutionPWM/16bitResolutionPWM.ino
+++ b/Code/libraries/MX1508/examples/16bitResolutionPWM/16bitResolutionPWM.ino
@ -0,0 +1,68 @@
+
+/*
+ * Created by: Cheng Saetern
+ * This example is meant to demonstrate the ability to adjust pwm frequency and/or  
+ * resolution for Arduino Nano/Uno pin 9 and 10 using function setPWM16(uint8_t prescaler, unsigned int resolution).
+ * Equation for fast pwm frequency = frequency of MPU(16Mhz)/prescaler/resolution
+ * F_PWM = 16000000/prescaler/resolution.
+ * prescaler argument value MUST be between 1-5, representing 1,8,64,256,1024 respectively. 
+ * resolution MUST be a value from 0-65535.
+ */
+ 
+#include <MX1508.h>
+
+#define PINA 9
+#define PINB 10
+#define NUMPWM 2
+// MX1508 schematics(in Chinese) can be found here at: http://sales.dzsc.com/486222.html
+/*
+ * MX1508(uint8_t pinIN1, uint8_t pinIN2, DecayMode decayMode, NumOfPwmPins numPWM);
+ * DecayMode must be FAST_DECAY or SLOW_DECAY,
+ * NumOfPwmPins, must be the value of 2 for setPWM16() function  
+ * PINA and PINB MUST!!! be pin 9 and 10 for setPWM16() function  
+ * Example MX1508 myMotor(10,9,FAST_DECAY, 2). 
+ */
+MX1508 motorA(PINA,PINB, FAST_DECAY, 2);
+
+int resolution = 1000;
+void setup() {
+  Serial.begin(115200);
+  
+  motorA.setPWM16(2,resolution); // prescaler at 8, resolution 1000, PWM frequency = 16Mhz/8/1000=2000Hz
+  // prescalar 1=1, 2=8, 3=64, 4=256, 5 =1028
+  /*------------ setPWM16 Class function is defined as below-----------------
+   void MX1508::setPWM16(uint8_t prescaler, unsigned int resolution){
+   if(prescaler > 5 || prescaler == 0) prescaler = 3; // default to 64 if not in range.
+    DDRB  |= _BV(PB1) | _BV(PB2);       // set pin 9and 10 as outputs 
+      TCCR1A = _BV(COM1A1) | _BV(COM1B1) | _BV(WGM11);    // non-inverting PWM, mode 14 fastPWM, TOP =ICR1
+    TCCR1B = _BV(WGM13) | _BV(WGM12) | prescaler ;  
+    ICR1 = resolution;
+    _pwmResolution = resolution;
+    _useAnalogWrite16 = true; 
+  }
+  */
+}
+/*
+ * Ramp up to pwm = resolution/2 , by increasing pwm by 1 every 50 millisecond. 
+ * then ramp down to pwm = -resolution/2, by decreasing pwm every 50 millisecond.
+ * positive value pwm results in forward direction.
+ * negative value pwm results in opposite direction. 
+ */
+void loop() {
+  // put your main code here, to run repeatedly:
+  static unsigned long lastMilli = 0;
+  static bool cwDirection = true; // assume initial direction(positive pwm) is clockwise
+  static int pwm = 1;
+  
+  if(millis()-lastMilli > 50){ // every 50 millisecond
+      if (cwDirection && pwm++ > resolution/2 ) {  
+        cwDirection = false;
+      } else if (!cwDirection && pwm-- < -(resolution/2)) {
+        cwDirection =  true;
+      } 
+    motorA.motorGo(pwm);
+    lastMilli = millis();
+    Serial.println(motorA.getPWM()); // we can just print pwm but just showing that member function getPWM() works.
+  }
+
+}
--- a/Code/libraries/MX1508/examples/exampleMX1508/exampleMX1508.ino
+++ b/Code/libraries/MX1508/examples/exampleMX1508/exampleMX1508.ino
@ -0,0 +1,44 @@
+
+#include <MX1508.h>
+
+#define PINA 9
+#define PINB 10
+#define NUMPWM 2
+// MX1508 schematics(in Chinese) can be found here at: http://sales.dzsc.com/486222.html
+/*
+ * MX1508(uint8_t pinIN1, uint8_t pinIN2, DecayMode decayMode, NumOfPwmPins numPWM);
+ * DecayMode must be FAST_DECAY or SLOW_DECAY,
+ * NumOfPwmPins, either use 1 or 2 pwm. 
+ * I recommend using 2 pwm pins per motor so spinning motor forward and backward gives similar response.
+ * if using 1 pwm pin, make sure its pinIN1, then set pinIN2 to any digital pin. I dont recommend this setting because 
+ * we need to use FAST_DECAY in one direction and SLOW_DECAY for the other direction.  
+ */
+MX1508 motorA(PINA,PINB, FAST_DECAY, NUMPWM);
+
+void setup() {
+  Serial.begin(115200);
+}
+/*
+ * Ramp up to pwm = 100, by increasing pwm by 1 every 50 millisecond. 
+ * then ramp down to pwm = -100, by decreasing pwm every 50 millisecond.
+ * positive value pwm results in forward direction.
+ * negative value pwm results in opposite direction. 
+ */
+void loop() {
+  // put your main code here, to run repeatedly:
+  static unsigned long lastMilli = 0;
+  static bool cwDirection = true; // assume initial direction(positive pwm) is clockwise
+  static int pwm = 1;
+  
+  if(millis()-lastMilli > 50){ // every 50 millisecond
+      if (cwDirection && pwm++ > 100 ) {  
+        cwDirection = false;
+      } else if (!cwDirection && pwm-- < -100) {
+        cwDirection =  true;
+      } 
+    motorA.motorGo(pwm);
+    lastMilli = millis();
+    Serial.println(motorA.getPWM()); // we can just print pwm but just showing that member function getPWM() works.
+  }
+
+}
--- a/Code/libraries/MX1508/keywords.txt
+++ b/Code/libraries/MX1508/keywords.txt
@ -0,0 +1,26 @@
+#######################################
+# Syntax Coloring Map For MX1508 Library
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+MX1508       KEYWORD1
+DecayMode    KEYWORD1
+NumOfPWMPins KEYWORD1
+
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+motorGo	      KEYWORD2
+setResolution	KEYWORD2
+getPWM	      KEYWORD2
+stopMotor	    KEYWORD2
+
+
+#######################################
+# Constants (LITERAL1)
+#######################################
--- a/Code/libraries/MX1508/library.properties
+++ b/Code/libraries/MX1508/library.properties
@ -0,0 +1,10 @@
+name=MX1508
+version=1.0.0
+author=Cheng Saetern 
+maintainer=Cheng Saetern
+sentence=A library that makes using mx1508 dual DC motor driver easier.
+paragraph=I know how very little resource there are on this motor driver.  A lot of sellers assume this IC is l298N but  its rather much more like pololu DDRV8833.
+category=Device Control
+url=https://github.com/Saeterncj/MX1508
+architectures=avr
+includes=MX1508.h
--- a/Code/libraries/PCD8544_SPI/Examples/PCD8544SPIbenchmark/PCD8544SPIbenchmark.ino
+++ b/Code/libraries/PCD8544_SPI/Examples/PCD8544SPIbenchmark/PCD8544SPIbenchmark.ino
@ -0,0 +1,112 @@
+#include <SPI.h>
+#include "PCD8544_SPI.h"
+
+#define USE_FRAME_BUFFER
+
+#ifdef USE_FRAME_BUFFER
+PCD8544_SPI_FB lcd;
+#else
+PCD8544_SPI lcd;
+#endif
+
+void setup(void)
+{
+	Serial.begin(9600);
+	lcd.begin();
+	lcd.print(F("Preparing benchmark"));
+#ifdef USE_FRAME_BUFFER
+	lcd.renderAll();
+#endif
+	delay(1000);
+}
+
+uint8_t bmp[] = {
+	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
+	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 
+	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
+};
+
+void loop(void) 
+{
+	size_t len;
+
+	lcd.clear();
+	unsigned long time = micros();
+	len = lcd.print(F("012345678901234567890123456789012345678901234567890123456789012345678901234567890123"));
+#ifdef USE_FRAME_BUFFER
+	lcd.renderString(0, 0, len);
+#endif
+	time = micros() - time;
+	delay(3000);
+
+	lcd.clear();
+	lcd.print(F("The time it took to print 84 chars is:    "));
+	lcd.print(time);
+#ifdef USE_FRAME_BUFFER
+	lcd.renderAll();
+#endif
+	delay(3000);
+
+	lcd.clear();
+	lcd.gotoXY(5,3);
+	lcd.print(F("Test gotoXY"));
+#ifdef USE_FRAME_BUFFER
+	lcd.renderAll();
+#endif
+	delay(3000);
+
+	lcd.clear();
+	time = micros();
+	lcd.writeBitmap(bmp, 10, 2, 25, 3);
+#ifdef USE_FRAME_BUFFER
+	lcd.renderAll();
+#endif
+	time = micros() - time;
+	delay(3000);
+
+	lcd.clear();
+	lcd.print(F("The time it took to draw a 25x3 (25x18) bitmap is: "));
+	lcd.print(time);
+#ifdef USE_FRAME_BUFFER
+	lcd.renderAll();
+#endif
+	delay(3000);
+	
+#ifdef USE_FRAME_BUFFER
+	lcd.clear();
+	time = micros();
+	lcd.writeRect(5, 5, 50, 40);
+	lcd.writeLine(75, 3, 75, 35);
+	lcd.writeLine(60, 10, 60, 40);
+	lcd.writeLine(10, 47, 60, 47);
+	lcd.renderAll();
+	time = micros() - time;
+	delay(3000);
+
+	lcd.clear();
+	len = lcd.print(F("The time it took draw a rect and 3 lines: "));
+	len += lcd.print(time);
+	lcd.renderString(0, 0, len);
+	delay(3000);
+
+	lcd.clear();
+	time = micros();
+	for (uint8_t row = 0; row < PCD8544_Y_PIXELS; row++)
+	{
+		for (uint8_t col = 0; col < PCD8544_X_PIXELS; col++)
+		{
+			uint8_t pixel = (col + row) % 2;
+			lcd.setPixel(col, row, pixel);
+		}
+	}
+	lcd.renderAll();
+	time = micros() - time;
+	delay(5000);
+
+	lcd.clear();
+	lcd.print(F("The time it took to run setPixel on all 4032 pixels and render it:    "));
+	lcd.print(time);
+	lcd.renderAll();
+	delay(5000);
+#endif
+}
--- a/Code/libraries/PCD8544_SPI/PCD8544_SPI.cpp
+++ b/Code/libraries/PCD8544_SPI/PCD8544_SPI.cpp
@ -0,0 +1,152 @@
+#include "PCD8544_SPI.h"
+#include <SPI.h>
+
+PCD8544_SPI::PCD8544_SPI()
+{
+}
+
+void PCD8544_SPI::begin(bool invert)
+{
+	this->begin(invert, 0xB0, 0x04, 0x15);
+}
+
+void PCD8544_SPI::begin(bool invert, uint8_t vop, uint8_t tempCoef, uint8_t bias)
+{
+	PCD8544_PORT |= (PIN_DC | PIN_RESET | PIN_CE);
+	PCD8544_DDR |= (PIN_DC | PIN_RESET | PIN_CE);
+	SPI.begin();
+	
+	// LCD init section:
+	
+	uint8_t invertSetting = invert ? 0x0D : 0x0C;
+	// Must reset LCD first!
+	PCD8544_PORT &= ~PIN_RESET;
+	PCD8544_PORT |= PIN_RESET;
+
+	this->writeLcd(PCD8544_COMMAND, 0x21); //Tell LCD that extended commands follow
+	this->writeLcd(PCD8544_COMMAND, vop); //Set LCD Vop (Contrast): Try 0xB1(good @ 3.3V) or 0xBF if your display is too dark
+	this->writeLcd(PCD8544_COMMAND, tempCoef); //Set Temp coefficent
+	this->writeLcd(PCD8544_COMMAND, bias); //LCD bias mode 1:48: Try 0x13 or 0x14. Mine works best with 1:65/1:65
+
+	this->writeLcd(PCD8544_COMMAND, 0x20); //We must send 0x20 before modifying the display control mode
+	this->writeLcd(PCD8544_COMMAND, invertSetting); //Set display control, normal mode. 0x0D for inverse
+
+	this->clear();
+}
+
+size_t PCD8544_SPI::write(uint8_t data)
+{
+	// Non-ASCII characters are not supported.
+	if (data < 0x20 || data > 0x7F) return 0;
+
+	uint8_t buf[6];
+	memcpy_P(buf, ASCII[data - 0x20], 5);
+	buf[5] = 0x00;
+	this->writeLcd(PCD8544_DATA, buf, 6);
+	this->advanceXY(6);
+	return 1;
+}
+
+void PCD8544_SPI::clear()
+{
+	for (uint16_t i = 0; i < BUF_LEN; i++)
+		this->writeLcd(PCD8544_DATA, 0x00);
+	//PCD8544_PORT = (PCD8544_PORT & ~PINS_CE_DC) | PCD8544_DATA;
+	//for (uint16_t i = BUF_LEN; i > 0; i--) SPI.transfer(0x00);
+	//PCD8544_PORT |= PIN_CE;
+	this->gotoXY(0, 0);
+}
+
+uint8_t PCD8544_SPI::gotoXY(uint8_t x, uint8_t y) 
+{	
+	if (x >= PCD8544_X_PIXELS || y >= PCD8544_ROWS) return PCD8544_ERROR;
+	//PCD8544_PORT = (PCD8544_PORT & ~PINS_CE_DC) | PCD8544_COMMAND;
+	//SPI.transfer(0x80 | x);
+	//SPI.transfer(0x40 | y);
+	//PCD8544_PORT |= PIN_CE;
+	this->writeLcd(PCD8544_COMMAND, 0x80 | x);  // Column.
+	this->writeLcd(PCD8544_COMMAND, 0x40 | y);  // Row.
+	this->m_Column = x;
+	this->m_Line = y;
+	return PCD8544_SUCCESS;
+}
+
+uint8_t PCD8544_SPI::writeBitmap(const uint8_t *bitmap, uint8_t x, uint8_t y, uint8_t width, uint8_t height)
+{
+	//if (x >= PCD8544_X_PIXELS || y >= PCD8544_ROWS) return;
+	////height = (this->m_Line + height > PCD8544_Y_PIXELS / 8) ? ((PCD8544_Y_PIXELS / 8) - this->m_Line) : height;
+	////width = (this->m_Column + width > PCD8544_X_PIXELS) ? (PCD8544_X_PIXELS - this->m_Column) : width;
+	//this->gotoXY(x, y);
+	//for (uint8_t y = 0; y < height; y++)
+	//{
+	//	for (uint8_t x = 0; x < width; x++)
+	//		this->writeLcd(PCD8544_DATA, bitmap[x + (y * width)]);
+	//	this->gotoXY(this->m_Column, this->m_Line + 1);
+	//}
+
+	//this->advanceXY(width);
+	
+	if (this->gotoXY(x, y) == PCD8544_ERROR) return PCD8544_ERROR;	
+	const uint8_t *maxY = bitmap + height * width;	
+
+	for (const uint8_t *y = bitmap; y < maxY; y += width)
+	{
+		//for (uint8_t x = 0; x < width; x++, y++)
+		//	this->writeLcd(PCD8544_DATA, *y);
+		
+		this->writeLcd(PCD8544_DATA, y , width);
+		this->gotoXY(this->m_Column, this->m_Line + 1);
+	}
+
+	this->advanceXY(width);
+}
+
+//void PCD8544_SPI::init(void) 
+//{
+//	// Must reset LCD first!
+//	PCD8544_PORT &= ~PIN_RESET;
+//	PCD8544_PORT |= PIN_RESET;
+//
+//	this->writeLcd(PCD8544_COMMAND, 0x21); //Tell LCD that extended commands follow
+//	this->writeLcd(PCD8544_COMMAND, 0xB0); //Set LCD Vop (Contrast): Try 0xB1(good @ 3.3V) or 0xBF if your display is too dark
+//	this->writeLcd(PCD8544_COMMAND, 0x04); //Set Temp coefficent
+//	this->writeLcd(PCD8544_COMMAND, 0x12); //LCD bias mode 1:48: Try 0x13 or 0x14. Mine works best with 1:65/1:65
+//
+//	this->writeLcd(PCD8544_COMMAND, 0x20); //We must send 0x20 before modifying the display control mode
+//	this->writeLcd(PCD8544_COMMAND, 0x0C); //Set display control, normal mode. 0x0D for inverse
+//}
+
+void PCD8544_SPI::advanceXY(uint8_t columns)
+{
+	this->m_Column += columns;
+	if (this->m_Column >= PCD8544_X_PIXELS)
+	{
+		this->m_Column %= PCD8544_X_PIXELS;
+		this->m_Line++;
+		this->m_Line %= PCD8544_ROWS;
+	}
+}
+
+void PCD8544_SPI::writeLcd(uint8_t dataOrCommand, const uint8_t *data, uint16_t count)
+{
+	PCD8544_PORT = (PCD8544_PORT & ~PINS_CE_DC) | dataOrCommand;
+	//for (uint16_t i = 0; i < count; i++)
+	//	SPI.transfer(data[i]);
+    for (uint16_t i = count; i > 0; i--)
+		SPI.transfer(data[count-i]);
+	PCD8544_PORT |= PIN_CE;
+}
+
+void PCD8544_SPI::writeLcd(uint8_t dataOrCommand, uint8_t data)
+{
+	PCD8544_PORT = (PCD8544_PORT & ~PINS_CE_DC) | dataOrCommand;
+	SPI.transfer(data);
+	PCD8544_PORT |= PIN_CE;
+}
+
+// Valid values are 0x00 - 0x7F.
+void PCD8544_SPI::contrast(uint8_t cnt)
+{
+	this->writeLcd(PCD8544_COMMAND, 0x21);          //Tell LCD that extended commands follow
+	this->writeLcd(PCD8544_COMMAND, 0X80 | cnt);  //Set LCD Vop (Contrast)
+}
--- a/Code/libraries/PCD8544_SPI/PCD8544_SPI.h
+++ b/Code/libraries/PCD8544_SPI/PCD8544_SPI.h
@ -0,0 +1,242 @@
+/********************************************************************
+ This is a "Fast PCD8544 Library". It is designed to be used with
+ Nokia 5110 type of display, driven by the PCD8544 controller.
+ This library uses hardware SPI of your Arduino microcontroller,
+ and does not supprt 'software SPI' mode.
+ 
+ Written by Arthur Liberman (aka 'The Coolest'). http://www.alcpu.com
+ Special thanks goes out to 'robtillaart' for his help with debugging
+ and optimization.
+
+ BSD license, check license.txt for more information.
+ All text above must be included in any redistribution.
+********************************************************************/
+
+// Version 1.2 -- Sept. 15, 2013
+
+#pragma once
+#include "Arduino.h"
+
+// It is very important to wire the LCD correctly. 
+// The following is the default wiring configuration for an Atmega168/328 based Arduino:
+// PIN_DC    D8 
+// PIN_RESET D9 
+// PIN_SCE   D10 
+// PIN_SDIN  D11 
+// PIN_SCLK  D13 
+
+// You may change pins DC, Reset and SCE to map them to different pins on your Arduino board. 
+// Please keep SDIN and SCLK connected to your Arduino's MOSI and SCK (hardware SPI) pins.
+// You can remap the LCD control pins by changing the following '#define' values:
+// Please refer to the pin/port mapping for your Arduino device:
+// http://arduino.cc/en/Hacking/PinMapping168
+// http://arduino.cc/en/Hacking/PinMapping2560
+// Pins labeled Px (PB, PC, etc.) stand for PORTx.
+// The current version of this library only allows the use of one port for the control pins.
+// Pins are mapped in binary order. Valid values are 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80.
+// Px0 is the LSB pin of the port, which in turn is represented by the hexadecimal number 0x01. 
+// Px7 is the MSB pin of the port, which in turn is represented by the hexadecimal number 0x80.
+
+// This is the port where the LCD is connected.
+#define PCD8544_PORT		PORTD
+#define PCD8544_DDR			DDRD	// Should be DDRx, x = port name (B, C, D, etc.)
+						
+#define PIN_DC				0x20	// D5
+#define PIN_RESET			0x08	// D3
+#define PIN_CE				0x10	// D4
+#define PINS_CE_DC			(PIN_DC | PIN_CE)
+
+// When DC is '1' the LCD expects data, when it is '0' it expects a command.
+#define PCD8544_COMMAND		0 
+#define PCD8544_DATA		PIN_DC
+
+// You may find a different size screen, but this one is 84 by 48 pixels
+#define PCD8544_X_PIXELS	84
+#define PCD8544_Y_PIXELS	48
+#define PCD8544_ROWS		6
+
+#define BUF_LEN				504 // 84 * 6 (6 rows of 8 bits)
+
+// Functions gotoXY, writeBitmap, renderString, writeLine and writeRect
+// will return PCD8544_SUCCESS if they succeed and PCD8544_ERROR if they fail.
+#define PCD8544_SUCCESS		1
+#define PCD8544_ERROR		0
+
+//Umlaute
+#define Ae 0x80
+#define ae 0x81
+#define Oe 0x82
+#define oe 0x83
+#define Ue 0x84
+#define ue 0x85
+
+
+class PCD8544_SPI : public Print
+{
+public:
+	PCD8544_SPI();	
+	
+	void begin(bool invert = false);
+	void begin(bool invert, uint8_t vop, uint8_t tempCoef, uint8_t bias);
+	void clear();
+	uint8_t gotoXY(uint8_t x, uint8_t y);
+	virtual size_t write(uint8_t uint8_t);
+	uint8_t writeBitmap(const uint8_t *bitmap, uint8_t x, uint8_t y, uint8_t width, uint8_t height);
+	void contrast(uint8_t cnt);
+
+private:
+
+	//void init(void);
+	void writeLcd(uint8_t dataOrCommand, uint8_t data);
+	void writeLcd(uint8_t dataOrCommand, const uint8_t *data, uint16_t count);
+
+	uint8_t m_Column;
+	uint8_t m_Line;
+	void advanceXY(uint8_t columns);
+};
+
+class PCD8544_SPI_FB : public Print
+{
+public:
+	PCD8544_SPI_FB();	
+
+	// Call a render method after any print/write methods are called.
+	// For best perofrmance aggragate all writes before calling a render method.
+	void renderLine();
+	void renderAll();
+	uint8_t renderString(uint8_t x, uint8_t y, uint16_t length);
+	
+	void setPixel(uint8_t x, uint8_t y, uint8_t value);
+	bool PCD8544_SPI_FB::getPixel(uint8_t x, uint8_t y);
+	
+	// WriteLine currently only supports horizontal and vertical lines.
+	uint8_t writeLine(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2);
+	uint8_t writeRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height, bool fill = false);
+	
+	void begin(bool invert = false);
+	void begin(bool invert, uint8_t vop, uint8_t tempCoef, uint8_t bias);
+	void clear(bool render = true);
+	uint8_t gotoXY(uint8_t x, uint8_t y);
+	virtual size_t write(uint8_t uint8_t);
+	uint8_t writeBitmap(const uint8_t *bitmap, uint8_t x, uint8_t y, uint8_t width, uint8_t height);
+	void contrast(uint8_t cnt);
+	void printOut(String string, uint8_t line, uint8_t start);
+
+private:
+
+	//void init(void);
+	void writeLcd(uint8_t dataOrCommand, uint8_t data);
+	void writeLcd(uint8_t dataOrCommand, const uint8_t *data, uint16_t count);
+
+	inline void swap(uint8_t &a, uint8_t &b);
+	uint16_t m_Position;
+	uint8_t m_Buffer[BUF_LEN];
+};
+
+//This table contains the hex values that represent pixels
+//for a font that is 5 pixels wide and 8 pixels high
+static const PROGMEM uint8_t ASCII[][5] = {
+	 { 0x00, 0x00, 0x00, 0x00, 0x00 } // 20   (space)
+	,{ 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 backslash
+	,{ 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 ~
+	,{ 0x78, 0x46, 0x41, 0x46, 0x78 } // 7f DEL
+//Umlaute
+	,{ 0xfd, 0x22, 0x22, 0x22, 0xfd } // 80 Ae
+	,{ 0x21, 0x54, 0x54, 0x54, 0x79 } // 81 ae
+	,{ 0x7d, 0x41, 0x41, 0x41, 0x7d } // 82 Oe
+	,{ 0x38, 0x88, 0x88, 0x88, 0x38 } // 83 oe
+	,{ 0x7e, 0x41, 0x40, 0x41, 0x7e } // 84 Ue
+	,{ 0x3c, 0x41, 0x40, 0x21, 0x7c } // 85 ue
+};
--- a/Code/libraries/PCD8544_SPI/PCD8544_SPI_FB.cpp
+++ b/Code/libraries/PCD8544_SPI/PCD8544_SPI_FB.cpp
@ -0,0 +1,284 @@
+#include "PCD8544_SPI.h"
+#include <SPI.h>
+
+PCD8544_SPI_FB::PCD8544_SPI_FB()
+{
+}
+
+void PCD8544_SPI_FB::begin(bool invert)
+{
+	this->begin(invert, 0xB0, 0x04, 0x12);
+}
+
+void PCD8544_SPI_FB::begin(bool invert, uint8_t vop, uint8_t tempCoef, uint8_t bias)
+{
+	PCD8544_PORT |= (PIN_DC | PIN_RESET | PIN_CE);
+	PCD8544_DDR |= (PIN_DC | PIN_RESET | PIN_CE);
+	SPI.begin();
+	
+	// LCD init section:
+	
+	uint8_t invertSetting = invert ? 0x0D : 0x0C;
+	// Must reset LCD first!
+	PCD8544_PORT &= ~PIN_RESET;
+	PCD8544_PORT |= PIN_RESET;
+
+	this->writeLcd(PCD8544_COMMAND, 0x21); //Tell LCD that extended commands follow
+	this->writeLcd(PCD8544_COMMAND, vop); //Set LCD Vop (Contrast): Try 0xB1(good @ 3.3V) or 0xBF if your display is too dark
+	this->writeLcd(PCD8544_COMMAND, tempCoef); //Set Temp coefficent
+	this->writeLcd(PCD8544_COMMAND, bias); //LCD bias mode 1:48: Try 0x13 or 0x14. Mine works best with 1:65/1:65
+
+	this->writeLcd(PCD8544_COMMAND, 0x20); //We must send 0x20 before modifying the display control mode
+	this->writeLcd(PCD8544_COMMAND, invertSetting); //Set display control, normal mode. 0x0D for inverse
+
+	this->clear();
+}
+
+size_t PCD8544_SPI_FB::write(uint8_t data)
+{
+	// Non-ASCII characters are not supported.
+	if (data < 0x20 || data > 0x7F) return 0;
+	
+	if (this->m_Position + 5 >= BUF_LEN) this->m_Position -= (BUF_LEN - 6);
+	memcpy_P(this->m_Buffer + this->m_Position, ASCII[data - 0x20], 5);
+	this->m_Buffer[this->m_Position+5] = 0x00;
+	this->m_Position += 6;
+	if (this->m_Position >= BUF_LEN) this->m_Position -= BUF_LEN;
+	//this->m_Position %= BUF_LEN;
+	return 1;
+}
+
+void PCD8544_SPI_FB::clear(bool render)
+{
+	memset(this->m_Buffer, 0x00, sizeof(this->m_Buffer));
+	if (render)
+		this->renderAll();
+	this->gotoXY(0, 0);
+}
+
+uint8_t PCD8544_SPI_FB::gotoXY(uint8_t x, uint8_t y) 
+{	
+	if (x >= PCD8544_X_PIXELS || y >= PCD8544_ROWS) return PCD8544_ERROR;
+	this->writeLcd(PCD8544_COMMAND, 0x80 | x);  // Column.
+	this->writeLcd(PCD8544_COMMAND, 0x40 | y);  // Row.
+	this->m_Position = (PCD8544_X_PIXELS * y) + x;
+	return PCD8544_SUCCESS;
+}
+
+uint8_t PCD8544_SPI_FB::writeBitmap(const uint8_t *bitmap, uint8_t x, uint8_t y, uint8_t width, uint8_t height)
+{
+	//if (x >= PCD8544_X_PIXELS || y >= PCD8544_Y_PIXELS) return;
+	//this->gotoXY(x, y);
+	//uint16_t pos = this->m_Position;
+	//for (uint8_t y = 0; y < height; y++)
+	//{
+	//	memcpy(this->m_Buffer + pos, bitmap + (y*width), width);
+	//	pos += PCD8544_X_PIXELS;
+	//}
+	
+	if (this->gotoXY(x, y) == PCD8544_ERROR) return PCD8544_ERROR;
+
+	uint8_t *pos = this->m_Buffer + this->m_Position;
+    const uint8_t *maxY = bitmap + height * width;	
+
+	for (const uint8_t *y = (uint8_t*) bitmap; y < maxY; y += width)
+	{
+		memcpy(pos, y, width);
+		pos += PCD8544_X_PIXELS;
+	}
+	return PCD8544_SUCCESS;
+}
+
+//void PCD8544_SPI_FB::init(void) 
+//{
+//	// Must reset LCD first!
+//	PCD8544_PORT &= ~PIN_RESET;
+//	PCD8544_PORT |= PIN_RESET;
+//
+//	this->writeLcd(PCD8544_COMMAND, 0x21); //Tell LCD that extended commands follow
+//	this->writeLcd(PCD8544_COMMAND, 0xB0); //Set LCD Vop (Contrast): Try 0xB1(good @ 3.3V) or 0xBF if your display is too dark
+//	this->writeLcd(PCD8544_COMMAND, 0x04); //Set Temp coefficent
+//	this->writeLcd(PCD8544_COMMAND, 0x12); //LCD bias mode 1:48: Try 0x13 or 0x14. Mine works best with 1:65/1:65
+//
+//	this->writeLcd(PCD8544_COMMAND, 0x20); //We must send 0x20 before modifying the display control mode
+//	this->writeLcd(PCD8544_COMMAND, 0x0C); //Set display control, normal mode. 0x0D for inverse
+//}
+
+void PCD8544_SPI_FB::renderLine()
+{	
+	this->writeLcd(PCD8544_DATA, this->m_Buffer, BUF_LEN);
+}
+
+void PCD8544_SPI_FB::renderAll()
+{	
+	this->gotoXY(0, 0);
+	this->writeLcd(PCD8544_DATA, this->m_Buffer, BUF_LEN);
+}
+
+uint8_t PCD8544_SPI_FB::renderString(uint8_t x, uint8_t y, uint16_t length)
+{
+	if (this->gotoXY(x, y) == PCD8544_ERROR) return PCD8544_ERROR;
+	length *= 6;
+	this->writeLcd(PCD8544_DATA, this->m_Buffer + this->m_Position, length);
+	this->m_Position += length;
+	return PCD8544_SUCCESS;
+}
+
+void PCD8544_SPI_FB::setPixel(uint8_t x, uint8_t y, uint8_t value)
+{
+	if (x >= PCD8544_X_PIXELS || y >= PCD8544_Y_PIXELS) return;
+	uint8_t bank = y / 8;
+	uint8_t bitMask = 1 << (y % 8);
+	uint8_t &byte = this->m_Buffer[(PCD8544_X_PIXELS * bank) + x];
+	if (value)
+		byte |= bitMask;
+	else
+		byte &= ~bitMask;
+}
+
+bool PCD8544_SPI_FB::getPixel(uint8_t x, uint8_t y)
+{
+	if (x >= PCD8544_X_PIXELS || y >= PCD8544_Y_PIXELS) return false;
+	uint8_t bank = y / 8;
+	uint8_t bitMask = 1 << (y % 8);
+	uint8_t &byte = this->m_Buffer[(PCD8544_X_PIXELS * bank) + x];
+	if((byte &= bitMask) > 0){
+	 return true;
+	} else{
+	   return false;
+	}
+}
+
+uint8_t PCD8544_SPI_FB::writeLine(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2)
+{
+	if (x1 == x2 || y1 == y2)
+	{
+		if (y1 > y2)
+			swap(y1, y2);
+		if (x1 > x2)
+			swap(x1, x2);
+		return this->writeRect(x1, y1, x2 - x1 + 1, y2 - y1 + 1);
+	}
+	else
+		return PCD8544_ERROR;
+}
+
+void PCD8544_SPI_FB::swap(uint8_t &a, uint8_t &b)
+{
+	uint8_t temp = a;
+	a = b;
+	b = temp;
+}
+//from top left to bottom right corner
+uint8_t PCD8544_SPI_FB::writeRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height, bool fill)
+{
+	if (x >= PCD8544_X_PIXELS || y >= PCD8544_Y_PIXELS || width == 0 || height == 0) return PCD8544_ERROR;
+
+	// Calculate the bitmasks for the pixels.
+	uint8_t bottom = y + height - 1;
+	uint8_t bankTop = y / 8;
+	uint8_t bankBottom = bottom / 8;
+	uint8_t bitMaskTop = 0x01;
+	uint8_t bitMaskBottom = 0x80;
+	uint8_t bitMaskTopFill = 0xFF;
+	uint8_t bitMaskBottomFill = 0xFF;
+	bitMaskTop <<= (y % 8);
+	bitMaskBottom >>= 7 - (bottom % 8);
+	bitMaskTopFill <<= (y % 8);
+	bitMaskBottomFill >>= 7 - (bottom % 8);
+
+	// When fill is selected, we'll use the FillMask.
+	if (fill)
+	{
+		bitMaskTop = bitMaskTopFill;
+		bitMaskBottom = bitMaskBottomFill;
+	}
+
+	// When the rectangle fits in a single bank, we AND the top and bottom masks
+	// So that we only fill the required area on the LCD.
+	if (bankTop == bankBottom)
+	{
+		bitMaskTop = fill ? bitMaskTop & bitMaskBottom : bitMaskTop | bitMaskBottom;
+		bitMaskTopFill &= bitMaskBottomFill;
+	}
+	this->gotoXY(x, bankTop);
+
+	// Write the left 'side' of the rectangle on the top bank.
+	this->m_Buffer[this->m_Position++] |= bitMaskTopFill;
+	// Write a line or a fill.
+	for (uint8_t i = 1; i < width-1; i++)
+		this->m_Buffer[this->m_Position++] |= bitMaskTop;
+	// Write the right 'side' of the rectangle on the top bank.
+	if (width > 1)
+		this->m_Buffer[this->m_Position++] |= bitMaskTopFill;
+
+	this->m_Position += (PCD8544_X_PIXELS - width);
+
+	// Write a fill across the middle banks or two sides of the rectangle.
+	if (bankBottom - bankTop > 1)
+	{
+			for (uint8_t i = bankTop + 1; i < bankBottom; i++)
+			{
+				if (fill)
+					memset(this->m_Buffer + this->m_Position, 0xFF, width);
+				else
+				{
+					this->m_Buffer[this->m_Position] = 0xFF;
+					this->m_Buffer[this->m_Position+width-1] = 0xFF;
+				}
+				this->m_Position += PCD8544_X_PIXELS;
+			}
+	}
+	// If the rectangle spans across more than one bank,
+	// apply the same logic for the bottom as the top.
+	if (bankBottom > bankTop)
+	{
+		this->m_Buffer[this->m_Position++] |= bitMaskBottomFill;
+		for (uint8_t i = 1; i < width-1; i++)
+			this->m_Buffer[this->m_Position++] |= bitMaskBottom;
+		if (width > 1)
+			this->m_Buffer[this->m_Position++] |= bitMaskBottomFill;
+	}
+	return PCD8544_SUCCESS;
+}
+
+void PCD8544_SPI_FB::writeLcd(uint8_t dataOrCommand, const uint8_t *data, uint16_t count)
+{
+	PCD8544_PORT = (PCD8544_PORT & ~PINS_CE_DC) | dataOrCommand;
+	//for (uint16_t i = 0; i < count; i++)
+	//	SPI.transfer(data[i]);
+    for (uint16_t i = count; i > 0; i--)
+		SPI.transfer(data[count-i]);
+	PCD8544_PORT |= PIN_CE;
+}
+
+void PCD8544_SPI_FB::writeLcd(uint8_t dataOrCommand, uint8_t data)
+{
+	PCD8544_PORT = (PCD8544_PORT & ~PINS_CE_DC) | dataOrCommand;
+	SPI.transfer(data);
+	PCD8544_PORT |= PIN_CE;
+}
+
+// Valid values are 0x00 - 0x7F.
+void PCD8544_SPI_FB::contrast(uint8_t cnt)
+{
+	this->writeLcd(PCD8544_COMMAND, 0x21);          //Tell LCD that extended commands follow
+	this->writeLcd(PCD8544_COMMAND, 0X80 | cnt);  //Set LCD Vop (Contrast)
+}
+// printing just one line and cut the overhang
+void PCD8544_SPI_FB::printOut(String string, uint8_t line, uint8_t start)
+{
+  line--;
+  if(line > 5) {
+    this->gotoXY(start,5);
+  } else {
+      this->gotoXY(start,line);
+  }
+  String subString;
+  if(string.length() > 14) {
+    subString += string.substring(0, 14);
+    this->print(subString);
+  } else {
+      this->print(string);
+  }
+}
--- a/Code/libraries/PCD8544_SPI/keywords.txt
+++ b/Code/libraries/PCD8544_SPI/keywords.txt
@ -0,0 +1,45 @@
+#######################################
+# Syntax Coloring Map For PCD8544_SPI
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+PCD8544_SPI	KEYWORD1
+PCD8544_SPI_FB	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+begin	KEYWORD2
+clear	KEYWORD2
+gotoXY	KEYWORD2
+writeBitmap	KEYWORD2
+renderLine	KEYWORD2
+renderAll	KEYWORD2
+renderString	KEYWORD2
+setPixel	KEYWORD2
+getPixel	KEYWORD2
+writeLine	KEYWORD2
+writeRect	KEYWORD2
+contrast	KEYWORD2
+printOut	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+
+PIN_DC	LITERAL1
+PIN_RESET	LITERAL1
+PIN_CE	LITERAL1
+PINS_CE_DC	LITERAL1
+PCD8544_COMMAND	LITERAL1
+PCD8544_DATA	LITERAL1
+PCD8544_X_PIXELS	LITERAL1
+PCD8544_Y_PIXELS	LITERAL1
+PCD8544_ROWS	LITERAL1
+PCD8544_SUCCESS	LITERAL1
+PCD8544_ERROR	LITERAL1
+BUF_LEN	LITERAL1
--- a/Code/libraries/PCD8544_SPI/license.txt
+++ b/Code/libraries/PCD8544_SPI/license.txt
@ -0,0 +1,25 @@
+Software License Agreement (BSD License)
+
+Copyright (c) 2013, ALCPU (Arthur Liberman).  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+3. Neither the name of the copyright holders nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- a/Code/libraries/myInterrupts/keywords.txt
+++ b/Code/libraries/myInterrupts/keywords.txt
@ -0,0 +1,32 @@
+#######################################
+# Syntax Coloring Map For NanoGame
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+myInterrupts	KEYWORD1
+
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+myInterrupts		KEYWORD2
+initTimer1		KEYWORD2
+disableTimer1Interrupt	KEYWORD2
+enableTimer1Interrupt	KEYWORD2
+
+initTimer2		KEYWORD2
+disableTimer2Interrupt	KEYWORD2
+enableTimer2Interrupt	KEYWORD2
+initOCR1B		KEYWORD2
+
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+
+#shiftDatPin		LITERAL1
+
--- a/Code/libraries/myInterrupts/myInterrupts.cpp
+++ b/Code/libraries/myInterrupts/myInterrupts.cpp
@ -0,0 +1,97 @@
+#include "myInterrupts.h"
+
+	myInterrupts::myInterrupts(){}
+
+	myInterrupts::initTimer1(){
+		// reset a timer unit (replace X by timer number)
+		TCCR1A = 0; // set TCCRXA register to 0
+		TCCR1B = 0; // set TCCRXB register to 0
+		TCNT1  = 0; // reset counter value
+
+		// 1:1
+		TCCR1B |= (1 << CS10);
+
+		OCR1A = 15999; // set compare match register of timer 1 (max. value: 65536 = 2^16 - 1), 16000 ~ 1 millisecond
+
+		//enable timer
+		TCCR1B |= (1 << WGM12); // enable timer1 CTC mode
+		TIMSK1 |= (1 << OCIE2A); // enable timer1 compare interrupt
+	}
+
+	myInterrupts::disableTimer1Interrupt(){
+		TIMSK1 &= ~(1 << OCIE2A); // disable timer1 compare interrupt
+	}
+
+	myInterrupts::enableTimer1Interrupt(){
+		TIMSK1 |= (1 << OCIE2A); // enable timer1 compare interrupt
+	}
+//Timer2
+	myInterrupts::initTimer2(){
+		// reset a timer unit (replace X by timer number)
+		TCCR2A = 0; // set TCCRXA register to 0
+		TCCR2B = 0; // set TCCRXB register to 0
+		TCNT2  = 0; // reset counter value
+
+		TCCR2A |= (1 << WGM21); // enable timer1 CTC mode
+		TCCR2A |= (1 << WGM20);
+		// 1:64
+		TCCR2B |= (1 << CS22);
+
+		OCR2A = 249; // set compare match register of timer 1 (max. value: 65536 = 2^16 - 1), 16000 ~ 1 millisecond
+
+		//enable timer
+		TIMSK2 |= (1 << OCIE2A); // enable timer1 compare interrupt
+	}
+
+	myInterrupts::initTimer2SoftPWM(){
+		// reset a timer unit (replace X by timer number)
+		TCCR2A = 0; // set TCCRXA register to 0
+		TCCR2B = 0; // set TCCRXB register to 0
+		TCNT2  = 0; // reset counter value
+
+		TCCR2A |= (1 << WGM21); // enable timer1 CTC mode
+		//TCCR2A |= (1 << WGM20);
+		// 1:8
+	//	TCCR2B |= (1 << CS20);
+		TCCR2B |= (1 << CS21);
+		//TCCR2B |= (1 << CS20);
+
+		OCR2A = 100; // set compare match register of timer 2 (max. value: 255 = 2^8 - 1) (100µs) ca. 78Hz
+
+		//enable timer
+		TIMSK2 |= (1 << OCIE2A); // enable timer1 compare interrupt
+
+	}
+
+	myInterrupts::disableTimer2Interrupt(){
+		TIMSK2 &= ~(1 << OCIE2A); // disable timer1 compare interrupt
+	}
+
+	myInterrupts::enableTimer2Interrupt(){
+		TIMSK2 |= (1 << OCIE2A); // enable timer1 compare interrupt
+	}
+//OCR1B
+
+	myInterrupts::initOCR1B(){
+		// reset a timer unit (replace X by timer number)
+		TCCR1A = 0; // set TCCRXA register to 0
+		TCCR1B = 0; // set TCCRXB register to 0
+		TCNT1  = 0; // reset counter value
+
+		//OC1B behaviour
+		TCCR1A |= (1 << COM1B1);
+	//	TCCR1A |= (1 << COM1B0);
+		TCCR1A |= (1 << WGM10);
+	//	TCCR1A |= (1 << WGM11);
+
+		// 1:1, 62.5kHz
+		TCCR1B |= (1 << CS10);
+
+		TCCR1B |= (1 << WGM12);
+	//	TCCR1B |= (1 << WGM13);
+
+		OCR1B = 127; // set compare match register of timer 1 (max. value: 65536 = 2^16 - 1), 16000 ~ 1 millisecond
+
+		//enable timer
+		TIMSK1 = 0;		//no Interrupts
+	}
--- a/Code/libraries/myInterrupts/myInterrupts.h
+++ b/Code/libraries/myInterrupts/myInterrupts.h
@ -0,0 +1,22 @@
+#pragma once
+
+#ifndef myInterrupts_h
+#define myInterrupts_h
+#include <Arduino.h>
+
+class myInterrupts {
+ public:
+	myInterrupts();
+	initTimer1();
+	disableTimer1Interrupt();
+	enableTimer1Interrupt();
+
+	initTimer2();
+  initTimer2SoftPWM();  //55µs
+	disableTimer2Interrupt();
+	enableTimer2Interrupt();
+
+	initOCR1B();
+};
+
+#endif
--- a/Code/libraries/shiftRegButtonLib/keywords.txt
+++ b/Code/libraries/shiftRegButtonLib/keywords.txt
@ -0,0 +1,50 @@
+#######################################
+# Syntax Coloring Map For shiftRegButtonLib
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+shiftRegButton	KEYWORD1
+shiftRegButtonLib	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+#shiftRegButton		KEYWORD2
+checkButtons		KEYWORD2
+checkButton		KEYWORD2
+checkButtonCycle	KEYWORD2
+clearButton		KEYWORD2
+clearAllButtons		KEYWORD2
+getButtonCycle		KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+
+shiftDatPin		LITERAL1
+shiftClkPin		LITERAL1
+shiftInPin		LITERAL1
+shiftDatPORT		LITERAL1
+shiftDatDDR		LITERAL1
+shiftClkPORT		LITERAL1
+shiftClkDDR		LITERAL1
+shiftInPORT		LITERAL1
+shiftInDDR		LITERAL1
+
+buttonUp 		LITERAL1
+buttonLeft 		LITERAL1
+buttonRight 		LITERAL1
+buttonDown 		LITERAL1
+
+buttonL1 		LITERAL1
+buttonStart 		LITERAL1
+buttonSelect 		LITERAL1
+buttonR1 		LITERAL1
+
+buttonA 		LITERAL1
+buttonB 		LITERAL1
+buttonC 		LITERAL1
--- a/Code/libraries/shiftRegButtonLib/shiftRegButtonLib.cpp
+++ b/Code/libraries/shiftRegButtonLib/shiftRegButtonLib.cpp
@ -0,0 +1,87 @@
+#include "shiftRegButtonLib.h"
+
+ shiftRegButton::shiftRegButton() {
+
+  //init Pins
+  shiftDatPORT &= ~shiftDatPin;
+  shiftClkPORT &= ~shiftClkPin;
+
+  //shiftInDDR &= ~shiftInPin;
+  shiftDatDDR |= shiftDatPin;
+  shiftClkDDR |= shiftClkPin;
+
+  shiftInPORT |= shiftInPin;
+
+  //init all flags
+  shiftDatHi;
+  for(uint8_t i = 0; i < numberOfButtons; i++, shiftClk()) {
+ //  buttonsPressed[i] = false;   
+ //  buttonsCycle[i] = false;  
+ 
+   buttonsTime[i] = 0;
+//   cycleFlag[i] = false;
+   //init shiftreg outputs to all 1's
+  }
+   buttonsPressed = 0;   
+   buttonsCycle = 0;
+   cycleFlag = 0;
+ }
+
+ shiftRegButton::checkButtons(void) {
+  //this procedure is needed by the 74HC595, other shift registers' behaviour may differ. See the datasheet of your part for more informations.
+  shiftDatLo;	//
+  shiftClk();	//zero to shift stage 0
+  shiftDatHi;	//
+  shiftClk();	//zero to parallel output 0
+  for(uint8_t i = 0; i < numberOfButtons; i++, shiftClk()) {
+    //is button i actually pressed?
+    if(buttonsInput()) {
+      buttonsPressed |= 1 << i;
+     // buttonsPressed[i] = true;
+     // cycleFlag[i] = true;
+      cycleFlag |= 1 << i;
+      buttonsTime[i]++;
+    } else {
+     //  buttonsPressed[i] = false;
+       buttonsPressed &= ~(1 << i);
+       buttonsTime[i] = 0;
+    }
+    checkButtonCycle(i);
+    //increase the time button i is pressed, or clear if it is not pressed anymore
+  }
+ }
+
+ bool shiftRegButton::checkButton(uint8_t n) {
+//  return buttonsPressed[n];
+  return buttonsPressed & (1 << n);
+ }
+ 
+ shiftRegButton::checkButtonCycle(uint8_t n) {
+//  if(!buttonsPressed[n] && cycleFlag[n]) {
+  if(!(buttonsPressed & (1 << n)) && (cycleFlag & (1 << n)) ) {
+//   buttonsCycle[n] = true;
+   buttonsCycle |= 1 << n;
+//   cycleFlag[n] = false;
+   cycleFlag &= ~(1 << n);
+  }
+ }
+ 
+ shiftRegButton::clearButton(uint8_t buttonToBeCleared) {
+//   buttonsCycle[buttonToBeCleared] = false;
+   buttonsCycle &= ~(1 << buttonToBeCleared);
+ }
+ 
+ shiftRegButton::clearAllButtons() {
+  for(uint8_t i = 0; i < numberOfButtons; i++) {  
+//   buttonsCycle[i] = false;
+   buttonsCycle &= ~(1 << i);
+  }
+ }
+
+ bool shiftRegButton::getButtonCycle(uint8_t n) {
+//   return buttonsCycle[n];
+   return buttonsCycle & (1 << n);
+ }
+ uint16_t shiftRegButton::getAnyPressed() {
+   return buttonsPressed;
+ }
--- a/Code/libraries/shiftRegButtonLib/shiftRegButtonLib.h
+++ b/Code/libraries/shiftRegButtonLib/shiftRegButtonLib.h
@ -0,0 +1,86 @@
+#pragma once
+
+#ifndef shiftRegButtonLib_h
+#define shiftRegButtonLib_h
+
+#include <Arduino.h>
+
+#define numberOfButtons 11
+//definitions for buttons
+#define buttonUp 0
+#define buttonLeft 2
+#define buttonRight 1
+#define buttonDown 3
+
+#define buttonL1 4
+#define buttonStart 5
+#define buttonSelect 6
+#define buttonR1 7
+
+#define buttonA 9
+#define buttonB 10
+#define buttonC 8
+//Pin and PORT assignments for shiftRegister(s)
+#define shiftDatPin  0x01	//D8
+#define shiftClkPin  0x40	//D6
+#define shiftInPin   0x02	//D9
+
+#define shiftDatPORT PORTB
+#define shiftDatDDR  DDRB	// Should be DDRx, x = port name (B, C, D, etc.)
+
+#define shiftClkPORT PORTD
+#define shiftClkDDR  DDRD
+
+#define shiftInPIN   PINB
+#define shiftInPORT  PORTB
+#define shiftInDDR   DDRB
+//Macros
+#define shiftDatLo (shiftDatPORT &= ~shiftDatPin)
+#define shiftDatHi (shiftDatPORT |= shiftDatPin)
+//74HC595 needs rising edge for sampling data
+inline void shiftClk(void) 
+{
+ shiftClkPORT |= shiftClkPin;
+ shiftClkPORT &= ~shiftClkPin;
+}
+
+inline bool buttonsInput(void)
+{
+ if((shiftInPIN &= shiftInPin) == 0) {
+  return true;
+ } else {
+    return false;
+ }
+}
+
+class shiftRegButton {
+ public: 
+
+  shiftRegButton();
+  checkButtons(void);
+//returns the state of a certain button
+  bool checkButton(uint8_t n);
+  checkButtonCycle(uint8_t n);
+//clears the cycle flag of a certain button
+  clearButton(uint8_t buttonToBeCleared);
+//clears all cycle flags
+  clearAllButtons();
+//return, if a certain button has been pressed (complete cycle, Hi-Lo-Hi)
+  bool getButtonCycle(uint8_t n);
+//was any button pressed?
+  uint16_t getAnyPressed();
+
+
+ private:
+   
+//  volatile bool buttonsPressed[numberOfButtons];    //flags to represent the actual (debounced) state of a button, no clearing needed 
+  volatile uint16_t buttonsPressed;		      //flags to represent the actual (debounced) state of a button, no clearing needed
+
+//  volatile bool buttonsCycle[numberOfButtons];      //flags to represent if a button did a whole hi-lo-hi cycle,      clearing needed
+  volatile uint16_t buttonsCycle;      //flags to represent if a button did a whole hi-lo-hi cycle,      clearing needed
+  uint8_t buttonsTime[numberOfButtons];    //the time in milliseconds a button was actually pressed,      no clearing needed, no overflow detection (max = 255ms)
+//  volatile bool cycleFlag[numberOfButtons];
+  volatile uint16_t cycleFlag;
+};
+
+#endif