diff --git a/compile_commands.json b/compile_commands.json
index a1775b4dd7edd23d0df2dc89570e3b5ee1905150..02f8d4eb769dd2a4bb7672c183bb5beb5c7d5cad 100644
--- a/compile_commands.json
+++ b/compile_commands.json
@@ -15,10 +15,10 @@
             "-fstrict-overflow",
             "-Winline",
             "-o",
-            "_build/t01sk.o",
-            "t01sk.c"
+            "_build/main.o",
+            "main.c"
         ],
-        "directory": "/home/bradley/src/c/fortuna-tasks/task1",
+        "directory": "/home/bradley/src/c/fortuna-mines",
         "file": "t01sk.c"
     }
 ]
diff --git a/lcd/font.h b/lcd/font.h
new file mode 100644
index 0000000000000000000000000000000000000000..3f0a7c871bfe3bce56fc51235d2e9167dea8b87f
--- /dev/null
+++ b/lcd/font.h
@@ -0,0 +1,104 @@
+/*  Author: Steve Gunn
+ * Licence: This work is licensed under the Creative Commons Attribution License.
+ *           View this license at http://creativecommons.org/about/licenses/
+ */
+
+#include <avr/pgmspace.h>
+
+const char font5x7[] PROGMEM = {
+	0x00, 0x00, 0x00, 0x00, 0x00, // SPACE
+	0x00, 0x00, 0x5F, 0x00, 0x00, // !
+	0x00, 0x03, 0x00, 0x03, 0x00, // "
+	0x14, 0x3E, 0x14, 0x3E, 0x14, // #
+	0x24, 0x2A, 0x7F, 0x2A, 0x12, // $
+	0x43, 0x33, 0x08, 0x66, 0x61, // %
+	0x36, 0x49, 0x55, 0x22, 0x50, // &
+	0x00, 0x05, 0x03, 0x00, 0x00, // '
+	0x00, 0x1C, 0x22, 0x41, 0x00, // (
+	0x00, 0x41, 0x22, 0x1C, 0x00, // )
+	0x14, 0x08, 0x3E, 0x08, 0x14, // *
+	0x08, 0x08, 0x3E, 0x08, 0x08, // +
+	0x00, 0x50, 0x30, 0x00, 0x00, // ,
+	0x08, 0x08, 0x08, 0x08, 0x08, // -
+	0x00, 0x60, 0x60, 0x00, 0x00, // .
+	0x20, 0x10, 0x08, 0x04, 0x02, // /
+	0x3E, 0x51, 0x49, 0x45, 0x3E, // 0
+	0x00, 0x04, 0x02, 0x7F, 0x00, // 1
+	0x42, 0x61, 0x51, 0x49, 0x46, // 2
+	0x22, 0x41, 0x49, 0x49, 0x36, // 3
+	0x18, 0x14, 0x12, 0x7F, 0x10, // 4
+	0x27, 0x45, 0x45, 0x45, 0x39, // 5
+	0x3E, 0x49, 0x49, 0x49, 0x32, // 6
+	0x01, 0x01, 0x71, 0x09, 0x07, // 7
+	0x36, 0x49, 0x49, 0x49, 0x36, // 8
+	0x26, 0x49, 0x49, 0x49, 0x3E, // 9
+	0x00, 0x36, 0x36, 0x00, 0x00, // :
+	0x00, 0x56, 0x36, 0x00, 0x00, // ;
+	0x08, 0x14, 0x22, 0x41, 0x00, // <
+	0x14, 0x14, 0x14, 0x14, 0x14, // =
+	0x00, 0x41, 0x22, 0x14, 0x08, // >
+	0x02, 0x01, 0x51, 0x09, 0x06, // ?
+	0x3E, 0x41, 0x59, 0x55, 0x5E, // @
+	0x7E, 0x09, 0x09, 0x09, 0x7E, // A
+	0x7F, 0x49, 0x49, 0x49, 0x36, // B
+	0x3E, 0x41, 0x41, 0x41, 0x22, // C
+	0x7F, 0x41, 0x41, 0x41, 0x3E, // D
+	0x7F, 0x49, 0x49, 0x49, 0x41, // E
+	0x7F, 0x09, 0x09, 0x09, 0x01, // F
+	0x3E, 0x41, 0x41, 0x49, 0x3A, // G
+	0x7F, 0x08, 0x08, 0x08, 0x7F, // H
+	0x00, 0x41, 0x7F, 0x41, 0x00, // I
+	0x30, 0x40, 0x40, 0x40, 0x3F, // J
+	0x7F, 0x08, 0x14, 0x22, 0x41, // K
+	0x7F, 0x40, 0x40, 0x40, 0x40, // L
+	0x7F, 0x02, 0x0C, 0x02, 0x7F, // M
+	0x7F, 0x02, 0x04, 0x08, 0x7F, // N
+	0x3E, 0x41, 0x41, 0x41, 0x3E, // O
+	0x7F, 0x09, 0x09, 0x09, 0x06, // P
+	0x1E, 0x21, 0x21, 0x21, 0x5E, // Q
+	0x7F, 0x09, 0x09, 0x09, 0x76, // R
+	0x26, 0x49, 0x49, 0x49, 0x32, // S
+	0x01, 0x01, 0x7F, 0x01, 0x01, // T
+	0x3F, 0x40, 0x40, 0x40, 0x3F, // U
+	0x1F, 0x20, 0x40, 0x20, 0x1F, // V
+	0x7F, 0x20, 0x10, 0x20, 0x7F, // W
+	0x41, 0x22, 0x1C, 0x22, 0x41, // X
+	0x07, 0x08, 0x70, 0x08, 0x07, // Y
+	0x61, 0x51, 0x49, 0x45, 0x43, // Z
+	0x00, 0x7F, 0x41, 0x00, 0x00, // [
+	0x02, 0x04, 0x08, 0x10, 0x20, // slash 
+	0x00, 0x00, 0x41, 0x7F, 0x00, // ]
+	0x04, 0x02, 0x01, 0x02, 0x04, // ^
+	0x40, 0x40, 0x40, 0x40, 0x40, // _
+	0x00, 0x01, 0x02, 0x04, 0x00, // `
+	0x20, 0x54, 0x54, 0x54, 0x78, // a
+	0x7F, 0x44, 0x44, 0x44, 0x38, // b
+	0x38, 0x44, 0x44, 0x44, 0x44, // c
+	0x38, 0x44, 0x44, 0x44, 0x7F, // d
+	0x38, 0x54, 0x54, 0x54, 0x18, // e
+	0x04, 0x04, 0x7E, 0x05, 0x05, // f
+	0x08, 0x54, 0x54, 0x54, 0x3C, // g
+	0x7F, 0x08, 0x04, 0x04, 0x78, // h
+	0x00, 0x44, 0x7D, 0x40, 0x00, // i
+	0x20, 0x40, 0x44, 0x3D, 0x00, // j
+	0x7F, 0x10, 0x28, 0x44, 0x00, // k
+	0x00, 0x41, 0x7F, 0x40, 0x00, // l
+	0x7C, 0x04, 0x78, 0x04, 0x78, // m
+	0x7C, 0x08, 0x04, 0x04, 0x78, // n
+	0x38, 0x44, 0x44, 0x44, 0x38, // o
+	0x7C, 0x14, 0x14, 0x14, 0x08, // p
+	0x08, 0x14, 0x14, 0x14, 0x7C, // q
+	0x00, 0x7C, 0x08, 0x04, 0x04, // r
+	0x48, 0x54, 0x54, 0x54, 0x20, // s
+	0x04, 0x04, 0x3F, 0x44, 0x44, // t
+	0x3C, 0x40, 0x40, 0x20, 0x7C, // u
+	0x1C, 0x20, 0x40, 0x20, 0x1C, // v
+	0x3C, 0x40, 0x30, 0x40, 0x3C, // w
+	0x44, 0x28, 0x10, 0x28, 0x44, // x
+	0x0C, 0x50, 0x50, 0x50, 0x3C, // y
+	0x44, 0x64, 0x54, 0x4C, 0x44, // z
+	0x00, 0x08, 0x36, 0x41, 0x41, // {
+	0x00, 0x00, 0x7F, 0x00, 0x00, // |
+	0x41, 0x41, 0x36, 0x08, 0x00, // }
+	0x02, 0x01, 0x02, 0x04, 0x02};// ~
+
diff --git a/lcd/ili934x.h b/lcd/ili934x.h
new file mode 100644
index 0000000000000000000000000000000000000000..662949745508998ca2be6832dec77740a3fe6c9d
--- /dev/null
+++ b/lcd/ili934x.h
@@ -0,0 +1,103 @@
+/*  Author: Steve Gunn
+ * Licence: This work is licensed under the Creative Commons Attribution License.
+ *           View this license at http://creativecommons.org/about/licenses/
+ */
+
+#define BLC			4
+#define RESET		7
+
+#define CMD_ADDR  0x4000
+#define DATA_ADDR 0x4100
+
+#define write_cmd(cmd)				asm volatile("sts %0,%1" :: "i" (CMD_ADDR), "r" (cmd) : "memory");
+#define write_data(data)			asm volatile("sts %0,%1" :: "i" (DATA_ADDR), "r" (data) : "memory");
+#define write_data16(data)			asm volatile("sts %0,%B1 \n\t sts %0,%A1" :: "i" (DATA_ADDR), "r" (data)  : "memory");
+#define write_cmd_data(cmd, data)	asm volatile("sts %0,%1 \n\t sts %2,%3" :: "i" (CMD_ADDR), "r" (cmd), "i" (DATA_ADDR), "r" (data)  : "memory");
+  
+/* Basic Commands */
+#define NO_OPERATION								0x00
+#define SOFTWARE_RESET								0x01
+#define READ_DISPLAY_IDENTIFICATION_INFORMATION		0x04
+#define READ_DISPLAY_STATUS							0x09
+#define READ_DISPLAY_POWER_MODE						0x0A
+#define READ_DISPLAY_MADCTL							0x0B
+#define READ_DISPLAY_PIXEL_FORMAT					0x0C
+#define READ_DISPLAY_IMAGE_FORMAT					0x0D
+#define READ_DISPLAY_SIGNAL_MODE					0x0E
+#define READ_DISPLAY_SELF_DIAGNOSTIC_RESULT			0x0F
+#define ENTER_SLEEP_MODE							0x10
+#define SLEEP_OUT									0x11	
+#define PARTIAL_MODE_ON								0x12
+#define NORMAL_DISPLAY_MODE_ON						0x13
+#define DISPLAY_INVERSION_OFF						0x20
+#define DISPLAY_INVERSION_ON						0x21
+#define GAMMA_SET									0x26
+#define DISPLAY_OFF									0x28
+#define DISPLAY_ON									0x29
+#define COLUMN_ADDRESS_SET							0x2A
+#define PAGE_ADDRESS_SET							0x2B
+#define MEMORY_WRITE								0x2C
+#define COLOR_SET									0x2D
+#define MEMORY_READ									0x2E
+#define PARTIAL_AREA								0x30
+#define VERTICAL_SCROLLING_DEFINITION				0x33
+#define TEARING_EFFECT_LINE_OFF						0x34
+#define TEARING_EFFECT_LINE_ON						0x35
+#define MEMORY_ACCESS_CONTROL						0x36	
+#define VERTICAL_SCROLLING_START_ADDRESS			0x37
+#define IDLE_MODE_OFF								0x38
+#define IDLE_MODE_ON								0x39
+#define PIXEL_FORMAT_SET							0x3A
+#define WRITE_MEMORY_CONTINUE						0x3C
+#define READ_MEMORY_CONTINUE						0x3E
+#define SET_TEAR_SCANLINE							0x44
+#define GET_SCANLINE								0x45
+#define WRITE_DISPLAY_BRIGHTNESS					0x51
+#define READ_DISPLAY_BRIGHTNESS						0x52
+#define WRITE_CTRL_DISPLAY							0x53
+#define READ_CTRL_DISPLAY							0x54
+#define WRITE_CONTENT_ADAPTIVE_BRIGHTNESS_CONTROL	0x55
+#define READ_CONTENT_ADAPTIVE_BRIGHTNESS_CONTROL	0x56
+#define WRITE_CABC_MINIMUM_BRIGHTNESS				0x5E
+#define READ_CABC_MINIMUM_BRIGHTNESS				0x5F
+#define READ_ID1									0xDA
+#define READ_ID2									0xDB
+#define READ_ID3									0xDC
+
+/* Extended Commands */
+#define RGB_INTERFACE_SIGNAL_CONTROL				0xB0
+#define FRAME_CONTROL_IN_NORMAL_MODE				0xB1
+#define FRAME_CONTROL_IN_IDLE_MODE					0xB2
+#define FRAME_CONTROL_IN_PARTIAL_MODE				0xB3
+#define DISPLAY_INVERSION_CONTROL					0xB4
+#define BLANKING_PORCH_CONTROL						0xB5
+#define DISPLAY_FUNCTION_CONTROL					0xB6
+#define ENTRY_MODE_SET								0xB7
+#define BACKLIGHT_CONTROL_1							0xB8
+#define BACKLIGHT_CONTROL_2							0xB9
+#define BACKLIGHT_CONTROL_3							0xBA
+#define BACKLIGHT_CONTROL_4							0xBB
+#define BACKLIGHT_CONTROL_5							0xBC
+#define BACKLIGHT_CONTROL_7							0xBE
+#define BACKLIGHT_CONTROL_8							0xBF
+#define POWER_CONTROL_1								0xC0
+#define POWER_CONTROL_2								0xC1
+#define POWER_CONTROL3_(FOR_NORMAL_MODE)			0xC2
+#define POWER_CONTROL4_(FOR_IDLE_MODE)				0xC3
+#define POWER_CONTROL5_(FOR_PARTIAL_MODE)			0xC4
+#define VCOM_CONTROL_1								0xC5
+#define VCOM_CONTROL_2								0xC7
+#define NV_MEMORY_WRITE								0xD0
+#define NV_MEMORY_PROTECTION_KEY					0xD1
+#define NV_MEMORY_STATUS_READ						0xD2
+#define READ_ID4									0xD3
+#define POSITIVE_GAMM_CORRECTION					0xE0
+#define NEGATIVE_GAMMA_CORRECTION					0xE1
+#define DIGITAL_GAMMA_CONTROL						0xE2
+#define DIGITAL_GAMMA_CONTROL2						0xE3
+#define INTERFACE_CONTROL							0xF6
+
+/* Undocumented commands */
+#define INTERNAL_IC_SETTING							0xCB
+#define GAMMA_DISABLE								0xF2
+
diff --git a/lcd/lcd.c b/lcd/lcd.c
new file mode 100644
index 0000000000000000000000000000000000000000..3eaf9cf98bf448ba180365f47267796b76aaf992
--- /dev/null
+++ b/lcd/lcd.c
@@ -0,0 +1,262 @@
+/*  Author: Steve Gunn
+ * Licence: This work is licensed under the Creative Commons Attribution License.
+ *           View this license at http://creativecommons.org/about/licenses/
+ *
+ *  
+ *  - Jan 2015  Modified for LaFortuna (Rev A, black edition) [KPZ]
+ */
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <util/delay.h>
+#include "font.h"
+#include "ili934x.h"
+#include "lcd.h"
+
+lcd display;
+
+void init_lcd()
+{
+    /* Enable extended memory interface with 10 bit addressing */
+    XMCRB = _BV(XMM2) | _BV(XMM1);
+    XMCRA = _BV(SRE);
+    DDRC |= _BV(RESET);
+    DDRB |= _BV(BLC);
+    _delay_ms(1);
+    PORTC &= ~_BV(RESET);
+    _delay_ms(20);
+    PORTC |= _BV(RESET);
+    _delay_ms(120);
+    write_cmd(DISPLAY_OFF);
+    write_cmd(SLEEP_OUT);
+    _delay_ms(60);
+    write_cmd_data(INTERNAL_IC_SETTING,          0x01);
+    write_cmd(POWER_CONTROL_1);
+        write_data16(0x2608);
+    write_cmd_data(POWER_CONTROL_2,              0x10);
+    write_cmd(VCOM_CONTROL_1);
+        write_data16(0x353E);
+    write_cmd_data(VCOM_CONTROL_2, 0xB5);
+    write_cmd_data(INTERFACE_CONTROL, 0x01);
+        write_data16(0x0000);
+    write_cmd_data(PIXEL_FORMAT_SET, 0x55);     /* 16bit/pixel */
+    set_orientation(West);
+    clear_screen();
+    display.x = 0;
+    display.y = 0;
+    display.background = BLACK;
+    display.foreground = WHITE;
+    write_cmd(DISPLAY_ON);
+    _delay_ms(50);
+    write_cmd_data(TEARING_EFFECT_LINE_ON, 0x00);
+    EICRB |= _BV(ISC61);
+    PORTB |= _BV(BLC);
+}
+
+void lcd_brightness(uint8_t i)
+{
+    /* Configure Timer 2 Fast PWM Mode 3 */
+    TCCR2A = _BV(COM2A1) | _BV(WGM21) | _BV(WGM20);
+    TCCR2B = _BV(CS20);
+    OCR2A = i;
+}
+
+void set_orientation(orientation o)
+{
+    display.orient = o;
+    write_cmd(MEMORY_ACCESS_CONTROL);
+    if (o==North) { 
+        display.width = LCDWIDTH;
+        display.height = LCDHEIGHT;
+        write_data(0x48);
+    }
+    else if (o==West) {
+        display.width = LCDHEIGHT;
+        display.height = LCDWIDTH;
+        write_data(0xE8);
+    }
+    else if (o==South) {
+        display.width = LCDWIDTH;
+        display.height = LCDHEIGHT;
+        write_data(0x88);
+    }
+    else if (o==East) {
+        display.width = LCDHEIGHT;
+        display.height = LCDWIDTH;
+        write_data(0x28);
+    }
+    write_cmd(COLUMN_ADDRESS_SET);
+    write_data16(0);
+    write_data16(display.width-1);
+    write_cmd(PAGE_ADDRESS_SET);
+    write_data16(0);
+    write_data16(display.height-1);
+}
+
+
+
+void set_frame_rate_hz(uint8_t f)
+{
+    uint8_t diva, rtna, period;
+    if (f>118)
+        f = 118;
+    if (f<8)
+        f = 8;
+    if (f>60) {
+        diva = 0x00;
+    } else if (f>30) {
+        diva = 0x01;
+    } else if (f>15) {
+        diva = 0x02;
+    } else {
+        diva = 0x03;
+    }
+    /*   !!! FIXME !!!  [KPZ-30.01.2015] */
+    /*   Check whether this works for diva > 0  */
+    /*   See ILI9341 datasheet, page 155  */
+    period = 1920.0/f;
+    rtna = period >> diva;
+    write_cmd(FRAME_CONTROL_IN_NORMAL_MODE);
+    write_data(diva);
+    write_data(rtna);
+}
+
+void fill_rectangle(rectangle r, uint16_t col)
+{
+    write_cmd(COLUMN_ADDRESS_SET);
+    write_data16(r.left);
+    write_data16(r.right);
+    write_cmd(PAGE_ADDRESS_SET);
+    write_data16(r.top);
+    write_data16(r.bottom);
+    write_cmd(MEMORY_WRITE);
+/*  uint16_t x, y;
+    for(x=r.left; x<=r.right; x++)
+        for(y=r.top; y<=r.bottom; y++)
+            write_data16(col);
+*/
+    uint16_t wpixels = r.right - r.left + 1;
+    uint16_t hpixels = r.bottom - r.top + 1;
+    uint8_t mod8, div8;
+    uint16_t odm8, odd8;
+    if (hpixels > wpixels) {
+        mod8 = hpixels & 0x07;
+        div8 = hpixels >> 3;
+        odm8 = wpixels*mod8;
+        odd8 = wpixels*div8;
+    } else {
+        mod8 = wpixels & 0x07;
+        div8 = wpixels >> 3;
+        odm8 = hpixels*mod8;
+        odd8 = hpixels*div8;
+    }
+    uint8_t pix1 = odm8 & 0x07;
+    while(pix1--)
+        write_data16(col);
+
+    uint16_t pix8 = odd8 + (odm8 >> 3);
+    while(pix8--) {
+        write_data16(col);
+        write_data16(col);
+        write_data16(col);
+        write_data16(col);
+        write_data16(col);
+        write_data16(col);
+        write_data16(col);
+        write_data16(col);
+    }
+}
+
+void fill_rectangle_indexed(rectangle r, uint16_t* col)
+{
+    uint16_t x, y;
+    write_cmd(COLUMN_ADDRESS_SET);
+    write_data16(r.left);
+    write_data16(r.right);
+    write_cmd(PAGE_ADDRESS_SET);
+    write_data16(r.top);
+    write_data16(r.bottom);
+    write_cmd(MEMORY_WRITE);
+    for(x=r.left; x<=r.right; x++)
+        for(y=r.top; y<=r.bottom; y++)
+            write_data16(*col++);
+}
+
+void clear_screen()
+{
+    display.x = 0;
+    display.y = 0;
+    rectangle r = {0, display.width-1, 0, display.height-1};
+    fill_rectangle(r, display.background);
+}
+
+void display_char(char c)
+{
+    uint16_t x, y;
+    PGM_P fdata; 
+    uint8_t bits, mask;
+    uint16_t sc=display.x, ec=display.x + 4, sp=display.y, ep=display.y + 7;
+
+    /*   New line starts a new line, or if the end of the
+         display has been reached, clears the display.
+    */
+    if (c == '\n') { 
+        display.x=0; display.y+=8;
+        if (display.y >= display.height) { clear_screen(); }
+        return;
+    }
+
+    if (c < 32 || c > 126) return;
+    fdata = (c - ' ')*5 + font5x7;
+    write_cmd(PAGE_ADDRESS_SET);
+    write_data16(sp);
+    write_data16(ep);
+    for(x=sc; x<=ec; x++) {
+        write_cmd(COLUMN_ADDRESS_SET);
+        write_data16(x);
+        write_data16(x);
+        write_cmd(MEMORY_WRITE);
+        bits = pgm_read_byte(fdata++);
+        for(y=sp, mask=0x01; y<=ep; y++, mask<<=1)
+            write_data16((bits & mask) ? display.foreground : display.background);
+    }
+    write_cmd(COLUMN_ADDRESS_SET);
+    write_data16(x);
+    write_data16(x);
+    write_cmd(MEMORY_WRITE);
+    for(y=sp; y<=ep; y++)
+        write_data16(display.background);
+
+    display.x += 6;
+    if (display.x >= display.width) { display.x=0; display.y+=8; }
+}
+
+void display_string(char *str)
+{
+    uint8_t i;
+    for(i=0; str[i]; i++) 
+        display_char(str[i]);
+}
+
+void display_string_xy(char *str, uint16_t x, uint16_t y)
+{
+    uint8_t i;
+    display.x = x;
+    display.y = y;
+    for(i=0; str[i]; i++)
+        display_char(str[i]);
+}
+
+void display_register(uint8_t reg)
+{
+	uint8_t i;
+
+	for(i = 0; i < 8; i++) {
+		if((reg & (_BV(7) >> i)) != 0) {
+			display_char( '1' );
+		} else {
+			display_char( '.' );
+		}
+	}
+}
+
diff --git a/lcd/lcd.h b/lcd/lcd.h
new file mode 100644
index 0000000000000000000000000000000000000000..736634671b06c0df6d632d2860f6b13d48b9fd9e
--- /dev/null
+++ b/lcd/lcd.h
@@ -0,0 +1,49 @@
+/*  Author: Steve Gunn
+ * Licence: This work is licensed under the Creative Commons Attribution License.
+ *           View this license at http://creativecommons.org/about/licenses/
+ */
+ 
+#include <avr/io.h>
+#include <stdint.h>
+
+
+#define LCDWIDTH	240
+#define LCDHEIGHT	320
+
+/* Colour definitions RGB565 */
+#define WHITE       0xFFFF
+#define BLACK       0x0000
+#define BLUE        0x001F      
+#define GREEN       0x07E0      
+#define CYAN        0x07FF      
+#define RED         0xF800      
+#define MAGENTA     0xF81F      
+#define YELLOW      0xFFE0      
+
+typedef enum {North, West, South, East} orientation;
+
+typedef struct {
+	uint16_t width, height;
+	orientation orient;
+	uint16_t x, y;
+	uint16_t foreground, background;
+} lcd;
+
+extern lcd display;
+
+typedef struct {
+	uint16_t left, right;
+	uint16_t top, bottom;
+} rectangle;	
+
+void init_lcd();
+void lcd_brightness(uint8_t i);
+void set_orientation(orientation o);
+void set_frame_rate_hz(uint8_t f);
+void clear_screen();
+void fill_rectangle(rectangle r, uint16_t col);
+void fill_rectangle_indexed(rectangle r, uint16_t* col);
+void display_char(char c);
+void display_string(char *str);
+void display_string_xy(char *str, uint16_t x, uint16_t y);
+void display_register(uint8_t reg);
diff --git a/mines.c b/mines.c
new file mode 100644
index 0000000000000000000000000000000000000000..88c42eac49cea1c441a792a1bc6953f3e02a869b
--- /dev/null
+++ b/mines.c
@@ -0,0 +1,205 @@
+/* COMP2215 Task 5---SKELETON */
+
+#include "os.h"
+#include <stdlib.h>
+
+
+int blink(int);
+int update_dial(int);
+int collect_delta(int);
+int check_switches(int);
+
+
+int position = 0;
+
+
+void main(void) {
+    os_init();
+
+    os_add_task( blink,            30, 1);
+    os_add_task( collect_delta,   500, 1);
+    os_add_task( check_switches,  100, 1);
+//	os_add_task( freeram_output,   20, 1);
+//	os_add_task( lose_mem,        250, 1);
+
+    sei();
+    for(;;){}
+
+}
+
+
+int collect_delta(int state) {
+	position += os_enc_delta();
+	return state;
+}
+
+
+int check_switches(int state) {
+
+	if (get_switch_press(_BV(SWN))) {
+			display_string("North\n");
+	}
+
+	if (get_switch_press(_BV(SWE))) {
+			display_string("East\n");
+	}
+
+	if (get_switch_short(_BV(SWS))) {
+			display_string("South\n");
+	}
+
+	if (get_switch_long(_BV(SWS))){
+		f_mount(&FatFs, "", 0);
+		if (f_open(&File, "myfile.txt", FA_READ) == FR_OK) {
+			uint16_t index = f_size(&File);
+			f_lseek(&File, index);
+			uint8_t arrayIndex = 0;
+			uint16_t* last25Newlines = calloc(25,25*sizeof(uint16_t));
+
+			char* character = malloc(sizeof(char));
+			UINT* br = malloc(sizeof(UINT));
+			display_string("\nLast 25 lines of saved data:\n");
+			for(;index > 0 && arrayIndex < 25; ){
+				index--;
+				f_read(&File, character,1,br);
+				if(*character == '\n'){
+					last25Newlines[arrayIndex] = index;
+					arrayIndex++;
+				}
+				f_lseek(&File,index);
+			}
+
+			for(arrayIndex = 24; arrayIndex > 0; arrayIndex--){
+				uint8_t lineLength = last25Newlines[arrayIndex-1] - last25Newlines[arrayIndex];
+				if(lineLength == 0){
+					continue;
+				}
+				char* line = calloc(lineLength, lineLength*sizeof(char));
+
+				f_read(&File,line,lineLength,br);
+				sprintf(line,line);
+				display_string(line);
+				free(line);
+			}
+
+			free(character);
+			free(br);
+			free(last25Newlines);
+			f_close(&File);
+		} else {
+			display_string("Can't read file! \n");
+		}
+	}
+
+	if (get_switch_press(_BV(SWW))) {
+			display_string("West\n");
+	}
+
+	if (get_switch_long(_BV(SWC))) {
+		f_mount(&FatFs, "", 0);
+		if (f_open(&File, "myfile.txt", FA_WRITE | FA_OPEN_ALWAYS) == FR_OK) {
+			f_lseek(&File, f_size(&File));
+			f_printf(&File, "Encoder position is: %d \r\n", position);
+			f_close(&File);
+			display_string("Wrote position\n");
+		} else {
+			display_string("Can't write file! \n");
+		}
+
+	}
+
+	if (get_switch_short(_BV(SWC))) {
+			display_string("[S] Centre\n");
+	}
+
+	if (get_switch_rpt(_BV(SWN))) {
+			display_string("[R] North\n");
+	}
+
+	if (get_switch_rpt(_BV(SWE))) {
+			display_string("[R] East\n");
+	}
+
+//	if (get_switch_rpt(_BV(SWS))) {
+//			display_string("[R] South\n");
+//	}
+
+	if (get_switch_rpt(_BV(SWW))) {
+			display_string("[R] West\n");
+	}
+
+	if (get_switch_rpt(SWN)) {
+			display_string("[R] North\n");
+	}
+
+
+	if (get_switch_long(_BV(OS_CD))) {
+		display_string("Detected SD card.\n");
+	}
+
+	return state;
+}
+
+
+
+
+int blink(int state) {
+	static int light = 0;
+	uint8_t level;
+
+	if (light < -120) {
+		state = 1;
+	} else if (light > 254) {
+		state = -20;
+	}
+
+
+	/* Compensate somewhat for nonlinear LED
+           output and eye sensitivity:
+        */
+	if (state > 0) {
+		if (light > 40) {
+			state = 2;
+		}
+		if (light > 100) {
+			state = 5;
+		}
+	} else {
+		if (light < 180) {
+			state = -10;
+		}
+		if (light < 30) {
+			state = -5;
+		}
+	}
+	light += state;
+
+	if (light < 0) {
+		level = 0;
+	} else if (light > 255) {
+		level = 255;
+	} else {
+		level = light;
+	}
+
+	os_led_brightness(level);
+	return state;
+}
+
+
+int freeram_output (int state){
+	char out[10];
+	sprintf(out, "%d\n", freeRam());
+	display_string_xy(out, 290, 000);
+	if(state == 10){
+		return 0;
+	} else {
+		return ++state;
+	}
+}
+
+int freeRam () {
+  extern int __heap_start, *__brkval;
+  int v;
+  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
+}
diff --git a/os.c b/os.c
new file mode 100644
index 0000000000000000000000000000000000000000..d254951e199009d2a5a3b24254bafa9f5397f40c
--- /dev/null
+++ b/os.c
@@ -0,0 +1,26 @@
+/*  _____          _                      ___  ____
+ * |  ___|__  _ __| |_ _   _ _ __   __ _ / _ \/ ___|
+ * | |_ / _ \| '__| __| | | | '_ \ / _` | | | \___ \
+ * |  _| (_) | |  | |_| |_| | | | | (_| | |_| |___) |
+ * |_|  \___/|_|   \__|\__,_|_| |_|\__,_|\___/|____/
+ *
+ */
+
+
+#include "os.h"
+#include "debug.h"
+#include "rios.h"
+#include "ruota.h"
+
+void os_init(void) {
+    /* 8MHz clock, no prescaling (DS, p. 48) */
+    CLKPR = (1 << CLKPCE);
+    CLKPR = 0;
+
+    DDRB  |=  _BV(PB7);  	 /* LED as output */
+
+    init_debug_uart1();
+    init_lcd();
+    os_init_scheduler();
+    os_init_ruota();
+}
diff --git a/os.h b/os.h
new file mode 100644
index 0000000000000000000000000000000000000000..e3b1a3058e4cea0ebfdc718d0052aac747ac2759
--- /dev/null
+++ b/os.h
@@ -0,0 +1,39 @@
+/* FortunaOS
+   _____             _                          ___   ____
+  |  ___|___   _ __ | |_  _   _  _ __    __ _  / _ \ / ___|
+  | |_  / _ \ | '__|| __|| | | || '_ \  / _` || | | |\___ \
+  |  _|| (_) || |   | |_ | |_| || | | || (_| || |_| | ___) |
+  |_|   \___/ |_|    \__| \__,_||_| |_| \__,_| \___/ |____/
+
+  Minimalist Operating System for LaFortuna board, build on:
+    - The RIOS Scheduler
+    - Peter Dannegger’s Code for the Rotary Encoder
+    - Peter Dannegger’s Code for Switch debouncing
+    - Steve Gunn’s display driver
+    - ChanN’s FAT File System
+
+  Occupies Timer T0 for scheduling and LED brightness.
+
+*/
+
+#ifndef OS_H
+#define OS_H
+
+#include <stdio.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include "lcd.h"
+#include "rios.h"
+#include "ruota.h"
+
+
+
+#define LED_ON      PORTB |=  _BV(PINB7)
+#define LED_OFF     PORTB &= ~_BV(PINB7)
+#define LED_TOGGLE  PINB  |=  _BV(PINB7)
+
+
+
+void os_init(void);
+
+#endif /* OS_H */
diff --git a/rios/rios.c b/rios/rios.c
new file mode 100644
index 0000000000000000000000000000000000000000..488e0dd6111ee386ecafbfdb375a970a5de431e7
--- /dev/null
+++ b/rios/rios.c
@@ -0,0 +1,196 @@
+/* FortunaOS: Scheduler
+
+   Template for preemptive version of RIOS implemented on an AVR
+   available from: http://www.cs.ucr.edu/~vahid/rios/rios_avr.htm
+
+   Slightly modified by Klaus-Peter Zauner, Feb 2014, Mar 2015.
+
+   For Copyright and License see end of file. 
+
+*/
+
+#include <stdint.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <math.h>
+#include <util/delay.h>
+#include "rios.h"
+
+
+
+
+typedef struct task {
+   uint8_t running;      /* 1 indicates task is running */
+   uint32_t period_ms;   /* Rate at which the task should tick in ms*/
+   uint32_t elapsedTime; /* Time since task's previous tick */
+   int (*TaskFct)(int);  /* Function to call for task's tick */
+   int state;            /* Current state of state machine */
+} task;
+
+task tasks[MAX_TASKS];
+int8_t tasksNum = -1;
+
+
+
+uint8_t runningTasks[MAX_TASKS+1] = {255}; /* Track running tasks, [0] always idleTask */
+const uint32_t idleTask = 255;             /* 0 highest priority, 255 lowest */
+uint8_t currentTask = 0;                   /* Index of highest priority task in runningTasks */
+
+unsigned schedule_time = 0;
+ISR(TIMER0_OVF_vect) {
+   uint8_t i;
+
+   for (i=0; i <= tasksNum; ++i) { /* Heart of scheduler code */
+      if (  (tasks[i].elapsedTime >= tasks[i].period_ms) /* Task ready */
+          && (runningTasks[currentTask] > i) /* Task priority > current task priority */
+          && (!tasks[i].running)             /* Task not already running (no self-preemption) */
+         ) {
+   
+         cli();
+         tasks[i].elapsedTime = 0;      /* Reset time since last tick */
+         tasks[i].running = 1;          /* Mark as running */
+         currentTask += 1;
+         runningTasks[currentTask] = i; /* Add to runningTasks */
+         sei();
+   
+         tasks[i].state = tasks[i].TaskFct(tasks[i].state); /* Execute tick */
+            
+         cli();
+         tasks[i].running = 0;                 /* Mark as not running */
+         runningTasks[currentTask] = idleTask; /* Remove from runningTasks */
+         currentTask -= 1;
+         sei();
+   
+      }
+      tasks[i].elapsedTime += 1;
+   }
+
+   
+}
+
+
+
+#ifdef OS_LED_BRIGHTNESS
+
+/* Use PWM mode to also control LED brightness from Timer 0 */
+void os_init_scheduler() {
+
+    /* Configure 8 bit Timer 0 for ISR  */
+	TCCR0A = _BV(COM0A1)    /* Clear OCA0A on Compare match, set on TOP */
+           | _BV(WGM01)		/* fast PWM mode */
+           | _BV(WGM00);
+
+    TCCR0B |= _BV(CS00)     
+            | _BV(CS01);   /* F_CPU/64, DS p.112 */
+
+
+    /* Interrupts at 488.3 Hz: FCPU/(510*N) with N=64, DS p.105 */  
+
+    TIMSK0 = _BV(TOIE0); /* enable overflow interrupt for T0, DS p.113  */
+    TCNT0 = 0;
+    OCR0A = 255;  /* LED full brightness */
+}
+
+void os_led_brightness(uint8_t level) {
+	if (level) {
+		OCR0A = level;
+		DDRB  |=  _BV(PINB7); 
+	} else {
+		DDRB  &=  ~_BV(PINB7); 
+	}
+}
+
+
+#else
+
+
+/* Use CTC mode to have periods of exactly 1 ms */
+void os_init_scheduler() {
+
+    /* Configure 8 bit Timer 0 for 1 ms ISR  */
+	TCCR0A |= _BV(WGM01);   /* Clear Timer on Compare match (CTC, Mode 2), DS p.111 */
+    TCCR0B |= _BV(CS00)     
+            | _BV(CS01);   /* F_CPU/64, DS p.112 */
+
+    OCR0A = (uint8_t)(F_CPU / (64UL * 1000) - 1); /* 1 kHz interrupts */
+
+    TIMSK0 = _BV(OCIE0A); /* enable compare match interrupt for T0, DS p.113  */
+    TCNT0 = 0;
+
+}
+
+
+void os_led_brightness(uint8_t brightness) {}
+
+#endif	/* OS_LED_BRIGHTNESS */
+
+
+
+int os_add_task(int (*fnc)(int), uint32_t period_ms, int initState) {
+   int t;
+
+   t = tasksNum + 1;
+ 
+   if (t >= MAX_TASKS) {
+	   t = -1;
+   } else {
+
+   #ifdef  OS_LED_BRIGHTNESS
+	  tasks[t].period_ms = 488.3/1000.0 * period_ms + 0.5;
+   #else
+	  tasks[t].period_ms = period_ms;
+   #endif	/* OS_LED_BRIGHTNESS */
+
+	  tasks[t].elapsedTime = tasks[t].period_ms;
+	  tasks[t].running = 0;
+	  tasks[t].TaskFct = fnc;
+	  tasks[t].state = initState;
+	  tasksNum = t; /* New task fully initialized */
+   }
+   
+   return t;
+}
+
+
+/*
+   Copyright (c) 2013 Frank Vahid, Tony Givargis, and
+   Bailey Miller. Univ. of California, Riverside and Irvine.
+   RIOS version 1.2
+
+   Copyright (c) 2012 UC Regents. All rights reserved.
+
+      Developed by: Frank Vahid, Bailey Miller, and Tony Givargis
+      University of California, Riverside; University of California, Irvine
+      <http://www.riosscheduler.org>http://www.riosscheduler.org
+
+      Permission is hereby granted, free of charge, to any person
+      obtaining a copy of this software and associated documentation
+      files (the "Software"), to deal with 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:
+
+      * Redistributions of source code must retain the above
+        copyright notice, this list of conditions and the following
+        disclaimers.
+      * Redistributions in binary form must reproduce the above
+        copyright notice, this list of conditions and the following
+        disclaimers in the documentation and/or other materials
+        provided with the distribution.
+      * Neither the names of any of the developers or universities nor
+        the names of its contributors may be used to endorse or
+        promote products derived from this Software without
+        specific prior written permission.
+
+      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 CONTRIBUTORS 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 WITH THE SOFTWARE.
+   (http://opensource.org/licenses/NCSA)
+
+*/
\ No newline at end of file
diff --git a/rios/rios.h b/rios/rios.h
new file mode 100644
index 0000000000000000000000000000000000000000..28e3aaf8357009549211b1eb1cc98b3d8507dc27
--- /dev/null
+++ b/rios/rios.h
@@ -0,0 +1,37 @@
+/* FortunaOS: Scheduler
+
+   Based on template for preemptive version of RIOS implemented on an
+   AVR available from: http://www.cs.ucr.edu/~vahid/rios/rios_avr.htm
+
+   For Copyright and License see end of rios.c file. 
+
+
+   Usage:
+     - Tasks can be added before or after scheduler has been initialized.
+     - Global Iterrupts need to be enabled manually. 
+     - Tasks can be added while the scheduler is running.
+
+*/
+
+#ifndef RIOS_H
+#define RIOS_H
+
+/* Limit for number of tasks: int8_t */
+#define MAX_TASKS 10
+
+
+/* Comment out the following line to get more precise 1 ms periods,
+   but loose brightness adjustement of LED 
+*/
+#define OS_LED_BRIGHTNESS
+
+void os_init_scheduler();
+
+void os_led_brightness(uint8_t brightness);
+
+
+/* Returns task priority (lower is higher) or -1 if not successful: */
+int os_add_task(int (*fnc)(int), uint32_t period_ms, int startState);
+
+
+#endif /* RIOS_H */
diff --git a/ruota/ruota.c b/ruota/ruota.c
new file mode 100644
index 0000000000000000000000000000000000000000..f8ff9496ab4e624b84d9f7ba8d72eb8e4bdf678c
--- /dev/null
+++ b/ruota/ruota.c
@@ -0,0 +1,188 @@
+/* ruota.c
+
+    Copyright Peter Dannegger (danni@specs.de)
+    http://www.mikrocontroller.net/articles/Entprellung 
+    http://www.mikrocontroller.net/articles/Drehgeber
+
+    Slightly adapted by Klaus-Peter Zauner for FortunaOS, March 2015
+
+*/
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include "rios.h"
+#include "ruota.h"
+
+
+#define ROTA	PE4
+#define ROTB	PE5
+
+#define COMPASS_SWITCHES (_BV(SWW)|_BV(SWS)|_BV(SWE)|_BV(SWN))
+#define ALL_SWITCHES (_BV(SWC) | COMPASS_SWITCHES | _BV(OS_CD))
+
+
+int8_t os_enc_delta(void);
+volatile int8_t delta;
+
+
+volatile uint8_t switch_state;   /* debounced and inverted key state:
+                                 bit = 1: key pressed */
+volatile uint8_t switch_press;   /* key press detect */
+volatile uint8_t switch_rpt;     /* key long press and repeat */
+ 
+
+
+int scan_encoder(int state);
+int scan_switches(int state);
+
+
+void os_init_ruota(void) {
+
+    /* Configure I/O Ports */
+	DDRE &= ~_BV(ROTA) & ~_BV(ROTB);  /* Rot. Encoder inputs */
+	PORTE |= _BV(ROTA) | _BV(ROTB);   /* Rot. Encoder pull-ups */
+
+	DDRE &= ~_BV(SWC);   /* Central button */
+	PORTE |= _BV(SWC);
+	
+	DDRC &= ~COMPASS_SWITCHES;  /* configure compass buttons for input */
+	PORTC |= COMPASS_SWITCHES;  /* and turn on pull up resistors */
+ 
+	DDRB &= ~_BV(OS_CD);   /* SD Card detection */
+	PORTB |= _BV(OS_CD);
+
+	/* Schedule encoder scan evry 2 ms */
+	os_add_task( scan_encoder,  2, 0);
+	/* Schedule button scan at 10 ms */
+	os_add_task( scan_switches, 10, 0);
+
+}
+
+
+int scan_encoder(int state) {
+     static int8_t last;
+     int8_t new, diff;
+     uint8_t wheel;
+
+     cli();
+     wheel = PINE;
+     new = 0;
+     if( wheel  & _BV(ROTB) ) new = 3;
+     if( wheel  & _BV(ROTA) )
+	 new ^= 1;		        	/* convert gray to binary */
+     diff = last - new;			/* difference last - new */
+     if( diff & 1 ){			/* bit 0 = value (1) */
+	     last = new;		       	/* store new as next last */
+	     delta += (diff & 2) - 1;	/* bit 1 = direction (+/-) */
+     }
+     sei();
+     
+     return state;
+}
+
+
+/* Read the two step encoder
+   -> call frequently enough to avoid overflow of delta
+*/
+int8_t os_enc_delta() {
+    int8_t val;
+
+    cli();
+    val = delta;
+    delta &= 1;
+    sei();
+
+    return val >> 1;
+}
+
+
+
+int scan_switches(int state) {
+  static uint8_t ct0, ct1, rpt;
+  uint8_t i;
+ 
+  cli();
+  /* 
+     Overlay port E for central button of switch wheel and Port B
+     for SD card detection switch:
+  */ 
+  i = switch_state ^ ~( (PINC|_BV(SWC)|_BV(OS_CD))	\
+                   & (PINE|~_BV(SWC)) \
+                   & (PINB|~_BV(OS_CD)));  /* switch has changed */
+  ct0 = ~( ct0 & i );                      /* reset or count ct0 */
+  ct1 = ct0 ^ (ct1 & i);                   /* reset or count ct1 */
+  i &= ct0 & ct1;                          /* count until roll over ? */
+  switch_state ^= i;                       /* then toggle debounced state */
+  switch_press |= switch_state & i;        /* 0->1: key press detect */
+ 
+  if( (switch_state & ALL_SWITCHES) == 0 )     /* check repeat function */
+     rpt = REPEAT_START;                 /* start delay */
+  if( --rpt == 0 ){
+    rpt = REPEAT_NEXT;                   /* repeat delay */
+    switch_rpt |= switch_state & ALL_SWITCHES;
+  }
+  sei();
+  
+  return state;
+}
+
+
+
+
+/*
+   Check if a key has been pressed
+   Each pressed key is reported only once.
+*/
+uint8_t get_switch_press( uint8_t switch_mask ) {
+  cli();                         /* read and clear atomic! */
+  switch_mask &= switch_press;         /* read key(s) */
+  switch_press ^= switch_mask;         /* clear key(s) */
+  sei();
+  return switch_mask;
+}
+
+
+
+
+/*
+   Check if a key has been pressed long enough such that the
+   key repeat functionality kicks in. After a small setup delay
+   the key is reported being pressed in subsequent calls
+   to this function. This simulates the user repeatedly
+   pressing and releasing the key.
+*/
+uint8_t get_switch_rpt( uint8_t switch_mask ) {
+  cli();                       /* read and clear atomic! */
+  switch_mask &= switch_rpt;         /* read key(s) */
+  switch_rpt ^= switch_mask;         /* clear key(s) */
+  sei();
+  return switch_mask;
+}
+
+ 
+/*
+   Check if a key is pressed right now
+*/
+uint8_t get_switch_state( uint8_t switch_mask ) {
+	switch_mask &= switch_state;
+	return switch_mask;
+}
+
+ 
+/*
+   Read key state and key press atomic!
+*/
+uint8_t get_switch_short( uint8_t switch_mask ) {
+  cli();                                         
+  return get_switch_press( ~switch_state & switch_mask );
+}
+
+ 
+/*
+    Key pressed and held long enough that a repeat would
+    trigger if enabled. 
+*/
+uint8_t get_switch_long( uint8_t switch_mask ) {
+  return get_switch_press( get_switch_rpt( switch_mask ));
+}
+
diff --git a/ruota/ruota.h b/ruota/ruota.h
new file mode 100644
index 0000000000000000000000000000000000000000..1580275b648a08322f211a0f59d4513b60b2919e
--- /dev/null
+++ b/ruota/ruota.h
@@ -0,0 +1,45 @@
+/* ruota.h
+
+   |      |     | Signal on |                       |
+   | Port | Pin | Schematic | Function              |
+   |------+-----+-----------+-----------------------|
+   | E    |   4 | ROTA      | Rotary Encoder A      |
+   | E    |   5 | ROTB      | Rotary Encoder B      |
+   | E    |   7 | SWC       | Switch wheel "Centre" |
+   |------+-----+-----------+-----------------------|
+   | C    |   2 | SWN       | Switch wheel "North"  |
+   | C    |   3 | SWE       | Switch wheel "East"   |
+   | C    |   4 | SWS       | Switch wheel "South"  |
+   | C    |   5 | SWW       | Switch wheel "West"   |
+   |------+-----+-----------+-----------------------|
+   | B    |   6 | CD        | SD Card Detetcion     |
+ 
+*/
+
+
+
+#define SWN     PC2
+#define SWE     PC3
+#define SWS     PC4
+#define SWW     PC5
+#define OS_CD   PB6
+#define SWC     PE7
+
+
+
+#define REPEAT_START    60      /* after 600ms */
+#define REPEAT_NEXT     10      /* every 100ms */
+ 
+void os_init_ruota(void);
+
+int8_t os_enc_delta(void);
+
+uint8_t get_switch_press( uint8_t switch_mask );
+uint8_t get_switch_rpt( uint8_t switch_mask );
+uint8_t get_switch_state( uint8_t switch_mask );
+uint8_t get_switch_short( uint8_t switch_mask );
+uint8_t get_switch_long( uint8_t switch_mask );
+
+
+
+