====== L1 Digital ======

Comment: Partial translation is needed!

====== Digital input/output ======

==== Warm-Up ====

Lights up:
  * pressing S1 1 LEDs,
  * pressing S2 2 LEDs,
  * pressing S3 3 LEDs 

<code c>
//
// HomeLab User interface module
// Warm-up exercise
//

#include <homelab/pin.h>
#include <homelab/delay.h>

pin led_red    = PIN(C, 5);
pin led_yellow = PIN(C, 4);
pin led_green  = PIN(C, 3);

pin button1 = PIN(C, 0);
pin button2 = PIN(C, 1);
pin button3 = PIN(C, 2);


int main(void)
{
	// LED setup
	pin_setup_output(led_red);
	pin_setup_output(led_yellow);
	pin_setup_output(led_green);

	// Button setup
	pin_setup_input_with_pullup(button1);
	pin_setup_input_with_pullup(button2);
	pin_setup_input_with_pullup(button3);

	// Switches LEDs off
	pin_set(led_green);
	pin_set(led_yellow);
	pin_set(led_red);

	while(true)
	{
		// Pressing S1 lights up LED1 (green)
		if(!pin_get_debounced_value(button1))
		{
			pin_clear(led_green);
			pin_set(led_yellow);
			pin_set(led_red);
		}
		// Pressing S2 lights up LED2 and LED3 (green and yellow)
		if(!pin_get_debounced_value(button2))
		{
			pin_clear(led_green);
			pin_clear(led_yellow);
			pin_set(led_red);
		}
		// Pressing S3 lights up all LEDs
		if(!pin_get_debounced_value(button3))
		{
			pin_clear(led_green);
			pin_clear(led_yellow);
			pin_clear(led_red);
		}
	}

}
</code>

==== Beginners exercise 1 ====
Imiteerib ülekäiguraja autode valgusfoori tööd. Kuni pole vajutatud ühelegi nupule, põleb autodele roheline LED. Pärast suvalisele nupule vajutamist hakkab roheline kolmeks sekundiks vilkuma, seejärel süttib kolmeks sekundiks kollane ning kümneks sekundiks punane ja lõpuks jääb uuesti pidevalt põlema roheline LED.

<code c>
//
// Traffic light
//

#include <homelab/pin.h>
#include <homelab/delay.h>

pin led_red    = PIN(C, 5);
pin led_yellow = PIN(C, 4);
pin led_green  = PIN(C, 3);

pin button1 = PIN(C, 0);
pin button2 = PIN(C, 1);
pin button3 = PIN(C, 2);


int main(void)
{
	unsigned char new_value, old_value = 0;
	unsigned short i;

	// Seab LEDid töökorda
	pin_setup_output(led_red);
	pin_setup_output(led_yellow);
	pin_setup_output(led_green);

	// Seab nupud töökorda
	pin_setup_input_with_pullup(button1);
	pin_setup_input_with_pullup(button2);
	pin_setup_input_with_pullup(button3);

	// Lülitab rohelise LED sisse ja teised LEDid välja
	pin_clear(led_green);
	pin_set(led_yellow);
	pin_set(led_red);

	while(true)
	{
		// Eelmise ja uue nupuväärtuse lugemine
		new_value = pin_get_debounced_value(button1) & pin_get_debounced_value(button2) & pin_get_debounced_value(button3);

		// Kui nuppu on vajutatud ja seejärel vabastatud
		if((!new_value) && (old_value))
		{
			// Vilgutab rohelist LED'i 3 sekundit
			for(i = 0; i < 6; i++)
			{
				pin_toggle(led_green);
				sw_delay_ms(500);
			}
			// Kustutab rohelise ja lülitab 3 sekundiks sisse kollase LEDi
			pin_set(led_green);
			pin_clear(led_yellow);
			sw_delay_ms(3000);
			// Kustutab kollase ja lülitab 10 sekundiks sisse punase LEDi
			pin_set(led_yellow);
			pin_clear(led_red);
			sw_delay_ms(10000);
			// Kustutab punase ja lülitab uuesti sisse rohelise LEDi
			pin_set(led_red);
			pin_clear(led_green);
		}

		old_value = new_value;
	}

}
</code>

==== Beginners exercise 2 ====
Loendab nupuvajutusi. Vajutus loetakse lõppenuks alles siis, kui nupp vabastatakse. Tulemus kuvatakse kahendkoodis LED-idel. Maksimaalne tulemus kolmel LED-il on 23-1. Roheline LED tähistab 1. bitti, kollane 2. bitti, punane 3. bitti.

<code c>
//
// Nupuvajutusi loendav programm
// Väljund binaarkoodis, maksimaalselt 7
//

#include <homelab/pin.h>
#include <homelab/delay.h>

pin led_red    = PIN(C, 5);
pin led_yellow = PIN(C, 4);
pin led_green  = PIN(C, 3);

pin button1 = PIN(C, 0);
pin button2 = PIN(C, 1);
pin button3 = PIN(C, 2);


int main(void)
{
	unsigned char new_value, old_value = 0;
	unsigned short count = 0;

	// Seab LEDid töökorda
	pin_setup_output(led_red);
	pin_setup_output(led_yellow);
	pin_setup_output(led_green);

	// Seab nupud töökorda
	pin_setup_input_with_pullup(button1);
	pin_setup_input_with_pullup(button2);
	pin_setup_input_with_pullup(button3);

	// Lülitab LEDid välja
	pin_set(led_green);
	pin_set(led_yellow);
	pin_set(led_red);

	while(true)
	{
		// Eelmise ja uue nupuväärtuse lugemine
		new_value = pin_get_debounced_value(button1) & pin_get_debounced_value(button2) & pin_get_debounced_value(button3);

		// Kui nuppu on vajutatud ja seejärel vabastatud
		if((!new_value) && (old_value))
		{
			// Liidab loendurile ühe juurde
			count++;

			// Kõrgeim bitt (4)
			// Aktiveeritakse kui loendurit neljaga jagades on tulemus >= 1
			if(((count % 8) / 4) > 0)
				pin_clear(led_red);
			else
				pin_set(led_red);

			// Keskmine bitt (2)
			// Aktiveeritakse kui eelmise tehte jääki kahega jagades on tulemus >= 1
			if(((count % 4) / 2) > 0)
				pin_clear(led_yellow);
			else
				pin_set(led_yellow);

			// Madalaim bitt (1)
			// Aktiveeritakse kui eelmise tehte jääk on >= 1
			if((count % 2) > 0)
				pin_clear(led_green);
			else
				pin_set(led_green);
		}

		old_value = new_value;
	}

}
</code>

==== Beginners exercise 3 ====
Vajutades nupule S1, süttib korraga LED1 ja LED3, vajutades nupule S2, süttib LED2, vajutades nupule S3, kustuvad kõik LED-id. Operatsioonid teostatakse otse vastavate registrite väärtusi muutes (ilma Kodulabori teegita).
<code c>
//
// Digitaalsete sisendite-väljundite ilma kodulabori teegita kasutamise näide
//

#include <avr/io.h>
#include <util/delay.h>

#define LED1	PC5
#define LED2	PC4
#define LED3	PC3

#define S1		0
#define S2		1
#define S3		2

int checkButton(int pin);

int main(void)
{
	DDRC = (1<<LED1) | (1<<LED2) | (1<<LED3);	// LED viigud väljunditena, ülejäänud sisenditena
	PORTC = (1<<LED1) | (1<<LED2) | (1<<LED3);	// Lülitab LEDid välja

	while(1)
	{
		// Nupu S1 vajutamisel lülitatakse sisse LED1 ja LED3
		if(checkButton(S1))
		{
			PORTC &= ~(1<<LED1) & ~(1<<LED3);
		}
		// Nupu S2 vajutamisel lülitatakse sisse LED2
		if(checkButton(S2))
		{
			PORTC &= ~(1<<LED2);
		}
		// Nupu S3 vajutamisel lülitatakse kõik LEDid välja
		if(checkButton(S3))
		{
			PORTC |= (1<<LED1) | (1<<LED2) | (1<<LED3);
		}
	}

}

//
// Kontrollib antud nupu väärtust
//
int checkButton(int pin)
{
	int i;	
	// Nupp on sees kui bitt on madal (0)
	if ((PINC & (1<<pin)) == 0)
	{
		// Põrkamise silumine
		for(i=0;i<25;i++)
		{
			if ((PINC & (1<<pin)) != 0)
				return 0;
			_delay_ms(1);
		}
	}
	else
		return 0;

	return 1;
}
</code>

==== Beginners exercise 4 ====
Loendab nupuvajutusi. Tulemus kuvatakse LED-i vilkumistega. Pärast igat nupule vajutamist suureneb vilgutamiste arv ühe võrra. Valida võib suvalise nupu. LED-i vilgutamiseks kasutada alamfunktsiooni, mille parameetriks on vilkumiste arv.
<code c>
//
// Nupuvajutusi loendav programm
// Väljund LEDi vilkumisega
//

#include <homelab/pin.h>
#include <homelab/delay.h>

void blink(int c); // Deklareerib alamfunktsiooni LEDi vilgutamiseks

pin led_yellow = PIN(C, 4);

pin button1 = PIN(C, 0);
pin button2 = PIN(C, 1);
pin button3 = PIN(C, 2);


int main(void)
{
	unsigned char new_value, old_value = 0;
	unsigned short count = 0;

	// Seab LEDi töökorda
	pin_setup_output(led_yellow);

	// Seab nupud töökorda
	pin_setup_input_with_pullup(button1);
	pin_setup_input_with_pullup(button2);
	pin_setup_input_with_pullup(button3);

	// Lülitab LEDi välja
	pin_set(led_yellow);

	while(true)
	{
		// Eelmise ja uue nupuväärtuse lugemine
		new_value = pin_get_debounced_value(button1) & pin_get_debounced_value(button2) & pin_get_debounced_value(button3);

		// Kui nuppu on vajutatud ja seejärel vabastatud
		if((!new_value) && (old_value))
		{
			// Liidab loendurile ühe juurde
			count++;

			// Vilgutab õige arv kordi LEDi
			blink(count);
		}

		old_value = new_value;
	}

}

//
// Alamfunktsioon LEDi vilgutamiseks
//
void blink(int c)
{
	int i = 0;

	// Muudab LEDi olekut iga 500ms tagant
	// Üheks vilgutuseks on tarvis LEDi olekut 2x muuta
	// Üks vilgutus võtab seega 1s
	for(i = 0; i < (c * 2); i++)
	{
		pin_toggle(led_yellow);
		sw_delay_ms(500);
	}
}
</code>
==== Beginners exercise 5 ====
Vajutades nupule S1, vilgutab punane LED morsekoodis „SOS“, vajutades nupule S2, vilgutab kollane LED „CQD“ ja, vajutades nupule S3, vilgutab roheline LED „OK“.
<code c>
//
// Morsekoodis teateid edastav programm
// Nupp 1 : punane SOS
// Nupp 2 : kollane CQD
// Nupp 3 : roheline OK
//

#include <homelab/pin.h>
#include <homelab/delay.h>

// Defineeri vajaminevad morsetähed
#define C	1
#define D	2
#define K	3
#define O	4
#define Q	5
#define S	6

// Deklareeri alamfunktsioonid
void blinkSos(void);
void blinkCqd(void);
void blinkOk(void);
void blinkChar(int c, pin led);
void blinkDot(pin led);
void blinkDash(pin led);

pin led_red    = PIN(C, 5);
pin led_yellow = PIN(C, 4);
pin led_green  = PIN(C, 3);

pin button1 = PIN(C, 0);
pin button2 = PIN(C, 1);
pin button3 = PIN(C, 2);


int main(void)
{
	// Seab LEDid töökorda
	pin_setup_output(led_red);
	pin_setup_output(led_yellow);
	pin_setup_output(led_green);

	// Seab nupud töökorda
	pin_setup_input_with_pullup(button1);
	pin_setup_input_with_pullup(button2);
	pin_setup_input_with_pullup(button3);

	// Lülitab LEDid välja
	pin_set(led_green);
	pin_set(led_yellow);
	pin_set(led_red);

	while(true)
	{
		// Nupu 1 vajutamisel vilgutatakse SOS
		if(!pin_get_value(button1))
			blinkSos();
		// Nupu 2 vajutamisel vilgutatakse CQD
		if(!pin_get_value(button2))
			blinkCqd();
		// Nupu 3 vajutamisel vilgutatakse OK
		if(!pin_get_value(button3))
			blinkOk();
	}

}

// Vilgutab SOS punase LEDiga
void blinkSos(void)
{
	blinkChar(S, led_red);
	blinkChar(O, led_red);
	blinkChar(S, led_red);
}

// Vilgutab CQD kollase LEDiga
void blinkCqd(void)
{
	blinkChar(C, led_yellow);
	blinkChar(Q, led_yellow);
	blinkChar(D, led_yellow);
}

// Vilgutab OK rohelise LEDiga
void blinkOk(void)
{
	blinkChar(O, led_green);
	blinkChar(K, led_green);
}

// Vilgutab parameetris määratud LEDiga punkti
void blinkDot(pin led)
{
	pin_clear(led);
	sw_delay_ms(100); // Standardse pikkusega punkt
	pin_set(led);
	sw_delay_ms(100); // Märgile järgnev paus
}

// Vilgutab parameetris määratud LEDiga kriipsu
void blinkDash(pin led)
{
	pin_clear(led);
	sw_delay_ms(300); // Standardse pikkusega kriips
	pin_set(led);
	sw_delay_ms(100); // Märgile järgnev paus
}

// Vilgutab eeldefineeritud mustri järgi
// parameetris 'c' olevat tähte parameetris 'led' oleval LEDil
void blinkChar(int c, pin led)
{
	switch(c)
	{
		// -.-.
		case C:
			blinkDash(led);
			blinkDot(led);
			blinkDash(led);
			blinkDot(led);
			break;
		// -..
		case D:
			blinkDash(led);
			blinkDot(led);
			blinkDot(led);
			break;
		// -.-
		case K:
			blinkDash(led);
			blinkDot(led);
			blinkDash(led);
			break;
		// ---
		case O:
			blinkDash(led);
			blinkDash(led);
			blinkDash(led);
			break;
		// --.-
		case Q:
			blinkDash(led);
			blinkDash(led);
			blinkDot(led);
			blinkDash(led);
			break;
		// ...
		case S:
			blinkDot(led);
			blinkDot(led);
			blinkDot(led);
			break;
	}
	sw_delay_ms(200); // Lisapaus peale tähte
}
</code>





===== Alternative solutions without library =====

For all exercises: Project->Configuration Options
  * Frequency: 14745600
  * Optimization: -Os (if not said otherwise in exercise comment)

==== Exercise 1 ====
Pressing S1 lights up 1 LED, pressing S2 lights up 2 LEDs and pressing S3 lights up 3 LEDs.

<code c>
/*
Title: Lab 1.1 LEDs
Platform: Atmega128 & Digital i/o board v3
Author: Raivo Sell 
Date: 2008
Comment:
LED = 0 (turned on)  		LED = 1 (turned off)
S = 0 (switch is on) 	S = 1 (switch is off)
PORT direction settings: 1-out	0-in
*/

#include <avr/io.h>

int main(void) {

    DDRC  = 0x38;  // DDRC  0b00111000
    PORTC = 0x3F;  // PORTC 0b00111111

	//Infinite loop
	while(1) {
		// If a button is pressed
		if (bit_is_clear(PINC, 0))	//Button S1
			PORTC=0x30; //LED 1 on - 0b00110000
		else if (bit_is_clear(PINC, 1))//Button S2
			PORTC=0x20; //LED 1&2 on - 0b00100000
		else if (bit_is_clear(PINC, 2))//Button S3
			PORTC&=0x00; //LED 1-3 on - 0b00000000
		else //Nothing pressed
			PORTC=0x3F; // All LEDs off
	}
}
</code>

==== Exercise 2 ====
Imitates a traffic light on key press (blinking of the yellow and green lights etc.) 

NB! Optimization must be turned off and the frequency defined.

<code c>

/*
Title: Lab 1.2 Traffic lights
Platform: Atmega128 & Digital i/o board v3
Author: Raivo Sell 
Date: 2006-2008
Comment: Optimization -O0
*/

#include <avr/io.h>

#define SET(x) |= (1<<x)  //define the high bit in port x
#define CLR(x) &=~(1<<x)  //define the low bit in port x
#define INV(x) ^=(1<<x)	//define the bit inverting in port x

// Empty cycle just to waste time
void aeg(int t) {
	int i,j;
	for (i=0;i<t;i++){
		for (j=0;j<32000;j++){;}
	}
}

// LED = 0 (on)  LED = 1 (off)
// Switch on = 0

int main(void) {
	
    int z;

    DDRC   = 0x38;  // PORTC three first bits are inputs, three next ports are outputs
    PORTC |= 0x3F;  // All LEDs off and button pull-ups on

	//loops until S1 is pressed
	while (bit_is_set(PINC, 0)){
		PORTC INV(4); // Blink yellow
		aeg(10);	
	}
	PORTC SET(4); // Yellow off
	
	//Infinite loop	
	while(1) {
			
			
			PORTC CLR(3); // Green on	
			aeg(100);
			for (z=0;z<5;z++){
				PORTC INV(3); // Blink green
				aeg(10);
			}	
			PORTC CLR(4); // Yellow on
			aeg(50);
			PORTC SET(4); // Yellow off
			PORTC CLR(5); // Red on
			aeg(100);
			PORTC CLR(4); // Add yellow
			aeg(50);
			PORTC SET(4); // Yellow off
			PORTC SET(5); // Red off
	}
}
</code>

==== Exercise 3 ====
Counts the key presses (key press ends when the button is released) in binary - max 7

<code c>
/*
Title: Lab 1.3 Binary counter
Platform: Atmega128 & Digital i/o board v3
Author: Raivo Sell, Rain Ellermaa 
Date: 2006-2008
Comment: 
*/

#define TRUE    1
#define FALSE   0
#define SET(x) |= (1<<x)  //define the high bit in port x
#define CLR(x) &=~(1<<x)  //define the low bit in port x

#define bit_get(p,m) ((p) & (m))

#include <inttypes.h>
#include <avr/io.h>
#include <util/delay.h>

uint8_t button_debounce();
uint8_t button_read();
int i= 0;

uint8_t button_debounce(){
   static uint16_t button_state = 0;   
   
   button_state = ( (button_state << 1) | !button_read() | 0xE000 );
   if ( button_state == 0xF000 ) return TRUE;
   return FALSE;
   }
   
uint8_t button_read(){
      return bit_get( PINC , 1 );
   } 

int main(void) {
	
    DDRC   = 0x38;  // DDRC  0b00111000 // PORTC three first bits are inputs, three next ports are outputs
    PORTC |= 0x3F;  // PORTC 0b00111000 // All LEDs off and button pull-ups on
    unsigned char led;

    while(1) {
	if ( button_debounce() == TRUE ) i++;
	_delay_ms( 1 );
	if (i>7) i=0;		
	led=~i;
	led <<=3;
	PORTC &= (0xC7 | led);
	PORTC |= (0x38 & led);
     }
}
</code>

==== Exercise 4 ====
Simulates door code lock. When pressing switches in this order S3 – S2 - S1 green LED goes on. All other combination will end up red LED. Every button pressing is indicated with yellow LED.

//NOT COMPLETED !!!//

<code c>
/*
Title: Lab 1.4 Code lock
Platform: Atmega128 & Digital i/o board v3
Author: Rain Ellermaa 
Date: 2009
Comment: 
*/
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

#define LOCKED 		1
#define UNLOCKED 	2

uint8_t code[3];
static uint8_t password[3] = {3,2,1};

//Blink LED on "pin"
static inline void Blink(uint8_t pin)
{
	PORTC &= ~(1<<pin);
	_delay_ms(100);
	PORTC |= (1<<pin);
	_delay_ms(100);
}

int Button(uint8_t pin)
{
	/* button is on when BIT is low (0) */
    if ((PINC & (1<<pin)) == 0) 
    {
    	for(uint8_t i=0;i<25;i++)
		{
        	if ((PINC & (1<<pin))!=0)
				return 0;
			_delay_ms(1);
		}
    }
	else
		return 0;
    return 1;
}

int CheckPress()
{
	if(Button(0)) 				//SW1 pressed
	{
		Blink(PC4);
		_delay_ms(100);
		return 1;
	}
	else if (Button(1)) 		//SW2 pressed
	{
		Blink(PC4);
		_delay_ms(100);
		return 2;
	}
	else if (Button(2)) 		//SW3 pressed
	{
		Blink(PC4);
		_delay_ms(100);
		return 3;
	}
	else
		return 4;
}

//get the user input 3 digit code.
void GetCode()
{
	for(uint8_t i=0;i<3;i++)
	{
		while(1)
		{
			uint8_t temp = CheckPress();
			if(temp != 4)
			{	
				code[i] = temp;
				break;
			}
		}
	}
	Blink(PC4);
}

//code to compare user inputted "code" buffer to the hardcoded "password" buffer
int CheckCode()
{
	for(uint8_t i=0;i<3;i++)
	{
		if(code[i] != password[i])
			return 0;
	}
	return 1;
}
 

int main(void)
{
	DDRC = (1<<PC3)|(1<<PC4)|(1<<PC5);	//LED pins as outputs, other inputs
	PORTC = (1<<PC3)|(1<<PC4)|(1<<PC5);	//LEDs off

	uint8_t status = UNLOCKED;

	while(1)
	{
		if((status == UNLOCKED) && (CheckPress() == 2))
		{
			status = LOCKED;

		}
		else if(status == LOCKED)
		{
			PORTC &= ~(1<<PC5);
			PORTC |= (1<<PC3);
			GetCode();
			if(!CheckCode())
			{
				PORTC &= ~(1<<PC5);
				PORTC |= (1<<PC3);
				status = LOCKED;
			}
			else if (CheckCode())
			{
				PORTC &= ~(1<<PC3);
				PORTC |= (1<<PC5);
				status = UNLOCKED;
			}
		}
	}
}

</code>

==== Exercise 5 ====
Simulates memory game. Every LED corresponds a button (LED1⇒S1, etc.) Controller flashed LEDs in random order and user have to repeat this order. Every next step in the sequence goes longer. After every insertion controller test the result. If wrong insertion is detected the game is over.
<code c>
/*
Title: Lab 1.5 Memory game
Platform: Atmega128 & Digital i/o board v3
Author: Rain Ellermaa 
Date: 2009
Comment: 
=====================================================
                  ++ INSTRUCTIONS: ++

   When the MCU powers up, all four lights will be active.
   Press any of the four corresponding buttons to start
   the game. Once the button is released, a single LED
   will flash briefly - press the corresponding button.

   All four LEDs will flash three times to indicate a
   correct entry. The same LED will again light, followed
   by another random LED. Repeat the sequence, the LEDs
   will all flash again and the sequence will begin again,
   getting longer by one LED after each correct entry. If
   at any point you make an error in repeating the sequence,
   all four LEDs will turn on and you will need to reset
   the MCU to begin another game.
   =====================================================
*/

// INCLUDES
#include <avr/io.h>
#include <util/delay.h>
#include "lcd.h"
#include "lcd.c"

// STATE DEFINES
#define STATE_Setup          0
#define STATE_PlayNextSeq    1
#define STATE_WaitForPlayer  2
#define STATE_CorrectSeq     3
#define STATE_LoseGame       4
#define STATE_WinGame        5

// MACROS
#define GetButton() (uint8_t)(~PINC & 7)
#define Timer0On()  TCCR0  |= (1<<CS00);


// PROTOTYPES
uint8_t CreateTimerRand(void);


// PROGRAM ROUTINES
int main(void)
{
	uint8_t CurrentState            = STATE_Setup;
	uint8_t SequenceBuffer[20]		= {};
	uint8_t CurrSeqPosC             = 0;
	uint8_t CurrentLevel            = 0;
	unsigned char echo[10];

	DDRC = (1<<PC3)|(1<<PC4)|(1<<PC5);       // LED port set as outputs
	PORTC = (1<<PC3)|(1<<PC4)|(1<<PC5);       // All LEDs off initially
 	lcd_init(LCD_DISP_ON);
	lcd_clrscr(); // Clear display and home cursor

	Timer0On();                   // Turn on the timer 0, to run at 1MHz (clock). This is used to determine the
	                              // Random sequence bytes; it's value is read after the last sequence byte is
	                              // entered by the user.

	while (1)                     // Infinite Loop
	{
		switch (CurrentState)
		{
			case STATE_Setup:
				CurrentLevel = 1;          	// Reset current level variable
				CurrSeqPosC  = 0;          	// Reset current sequence position variable

				PORTC &= ~(7<<PC3);       	// All LEDs on

				while (!(GetButton()))		// Wait until a button is pressed, store pressed button
					;  						

				PORTC |= (7<<PC3);        	// All LEDs off

				SequenceBuffer[0] = CreateTimerRand(); // Create a random sequence byte from the timer value for the first sequence

				_delay_ms(400);           	// Wait a 400ms before continuing

				CurrentState = STATE_PlayNextSeq;
				break;
			
			case STATE_PlayNextSeq:
				PORTC &= (~SequenceBuffer[CurrSeqPosC]<<PC3);    	// Turn on sequence LED
				_delay_ms(200);                                    	// Wait 200ms
				PORTC |= (SequenceBuffer[CurrSeqPosC]<<PC3);   		// Turn off sequence LED
				_delay_ms(200);                                     // Wait 200ms

				if (++CurrSeqPosC == CurrentLevel)                  // Sequence playing complete, wait for player input
				{
					CurrSeqPosC  = 0;                               // Reset sequence position counter to 0
					CurrentState = STATE_WaitForPlayer;
				}
				else                                                // Sequence still playing
				{
					CurrentState = STATE_PlayNextSeq;
				}
				break;
			
			case STATE_WaitForPlayer:
				while (GetButton()) {};                             // Wait until all buttons released before accepting key

    			uint8_t PressedButton = 0;

				while (!(PressedButton))                            // Wait until a button is pressed, store pressed button
					PressedButton = GetButton();

				PORTC &= (~PressedButton<<PC3);                  	// Light up the pressed button's LED
				_delay_ms(200);                                     // Wait 200ms
				PORTC |= (PressedButton<<PC3);                  	// Turn off the pressed button's LED
				_delay_ms(200);                                     // Wait 200ms

				if (PressedButton == SequenceBuffer[CurrSeqPosC])   // Correct button pressed
				{
					if (++CurrSeqPosC == CurrentLevel)              // Sequence finished by player
					{
						CurrentLevel++;                             // Increase the level by one
						CurrSeqPosC = 0;                            // Reset sequence position counter to 0

						if (CurrentLevel > 20)                    	// A genious has completed the entire sequence
						{
							CurrentState = STATE_WinGame;
						}
						else                                        // Still more room in the buffer, create a new random byte and set the state accordingly
						{
							SequenceBuffer[CurrentLevel - 1] = CreateTimerRand(); // Create the next sequence byte from the timer

							CurrentState = STATE_CorrectSeq;
						}
					}
					else
					{
						CurrentState = STATE_WaitForPlayer;
					}
				}
				else
				{
					CurrentState = STATE_LoseGame;
				}
				break;
			
			case STATE_CorrectSeq:
				for (uint8_t FlashCount=0; FlashCount<3; FlashCount++) // Flash the LEDs three times
				{
					PORTC &= ~(7<<PC3);                            	// Turn on all the LEDs
					_delay_ms(100);                                 // Wait 100ms
					PORTC |= (7<<PC3);                             	// Turn off all the LEDs
					_delay_ms(100);                                 // Wait 100ms
				}

				CurrentState = STATE_PlayNextSeq;
				break;
			
			case STATE_LoseGame:
				PORTC &= ~(7<<PC3);            	// Turn on all LEDs
				// Put string to display (line 1) with linefeed
				itoa(CurrentLevel-1,echo);
				lcd_gotoxy(0,0);
				lcd_puts("Vastasid:");
				lcd_gotoxy(0,1);
				lcd_puts(echo);

				CurrentState = STATE_LoseGame;
				break;
			
			case STATE_WinGame:
				PORTC ^= (7<<PC3);  			// Invert LEDs status
				_delay_ms(200);                 // Wait 200ms before continuing

				CurrentState = STATE_WinGame;
				break;
		}
	}
}

uint8_t CreateTimerRand(void)
{
	uint8_t RVal = TCNT0;   // Get the timer0 value into a variable

	// Priority encoder: Uses ordered tests to save code so that only
	// the first matching test code is executed.
	if      (RVal <= 85)  RVal = (1<<0);
	else if (RVal <= 170) RVal = (1<<1);
	else                  RVal = (1<<2);

	return RVal;            // Shift 1 by the new random number between 0 and 2, return the new sequence byte
}

</code>

==== Exercise 6 ====
Measures reaction time. Program start when one button is pressed, then a LED goes on and user have to press a button under the LED. Sequence and time when LED goes on is random. Best result in milliseconds is presented to the user (on the 7-seg display or LCD). ({{:software:lcd.c|lcd.c}} {{:software:lcd.h|lcd.h}})
<code c>
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include "lcd.h"


volatile uint8_t ovf = 0;

//Timer 1 Overflow interrupt to indicate too slow input
ISR(TIMER1_OVF_vect)
{
	ovf =1;
}

//Starts the Timer Counter unit
static inline void TimerStart()
{
	TCNT1 = 0;
	TCCR1B = (4<<CS10); //57600 Hz clock (256 prescale)
}

//Stops the Timer
static inline void TimerStop()
{
	TCCR1B = 0;
}

//Blink all LEDs
static inline void Blink()
{
	PORTC &= ~((1<<PC3)|(1<<PC4)|(1<<PC5));
	_delay_ms(100);
	PORTC |= (1<<PC3)|(1<<PC4)|(1<<PC5);
	_delay_ms(100);
}

static inline int Button(uint8_t pin)
{
	/* button is on when BIT is low (0) */
    if ((PINC & (1<<pin)) == 0)
    {
    	for(uint8_t i=0;i<25;i++)
		{
        	if ((PINC & (1<<pin))!=0)
				return 0;
			_delay_ms(1);
		}
    }
	else
		return 0;
    return 1;
}

int CheckPress()
{
	if(Button(0)) 				//SW1 pressed
	{
		Blink();
		_delay_ms(500);
		return 1;
	}
	else if (Button(1)) 		//SW2 pressed
	{
		Blink();
		_delay_ms(500);
		return 2;
	}
	else if (Button(2)) 		//SW3 pressed
	{
		Blink();
		_delay_ms(500);
		return 3;
	}
	else
		return 4;
}

int main(void)
{
	DDRC = (1<<PC3)|(1<<PC4)|(1<<PC5);	//LED pins outputs, other inputs
	PORTC = (1<<PC3)|(1<<PC4)|(1<<PC5);	//LEDs off

	TIMSK = (1<<TOIE1);					//Enable overflow interrupt for Timer1
	sei();								//Global interrupts enable
	
	//initialize LCD, clear screen and display welcome text
	lcd_init(LCD_DISP_ON);
	lcd_clrscr();
	lcd_puts("Reaction timer\n");
	_delay_ms(1000);
	lcd_puts("press any key");
	
	uint16_t rng = 500;
	uint16_t temp = 0;

	while(1)
	{
		if(CheckPress()!=4)				//Wait for "any key"
		{
			char buffer[6];
			rng = rng * 10;
			lcd_clrscr();
			
			_delay_ms(rng);				//Wait for random amount of time calculated from
										//the time it took to press "any key"			
			
			if(rng < 2000)				//select which random LED to turn on and wait for
			{
				PORTC &= ~(1<<PC3);
				TimerStart();
				while((PINC & (1<<PC0))&&(!ovf)) 	//wait for user input or timer overflow
					;
				TimerStop();
			}
			else if((rng >= 2000)&&(rng < 3500))
			{
				PORTC &= ~(1<<PC4);
				TimerStart();
				while((PINC & (1<<PC1))&&(!ovf))	//wait for user input or timer overflow
					;
				TimerStop();
			}
			else if(rng >= 3500)
			{
				PORTC &= ~(1<<PC5);
				TimerStart();
				while((PINC & (1<<PC2))&&(!ovf))	//wait for user input or timer overflow
					;
				TimerStop();
			}
			
			lcd_clrscr();
			lcd_puts("Time: ");
			
			if(ovf == 1)					//if it took too long to input say so
			{
				lcd_puts(" Too slow");
				ovf = 0;
			}
			else							//else calculate time in ms
			{
				temp = TCNT1 / 576 * 10 ;
				itoa(temp,buffer,10);
				lcd_puts(buffer);
			}
			lcd_puts("ms\nPress any key");	//displat information on screen
			PORTC = (1<<PC3)|(1<<PC4)|(1<<PC5);
			_delay_ms(500);
		}
		rng++;
		
		if(rng > 500)
			rng = 50;
	}
}

</code>

==== Exercise 7 ====
Flashes LEDs with different frequency using timer. Frequency can be changed by the buttons. (S1 – 1 Hz, S2 – 0,5 Hz, S3 – 0,1 Hz).
<code c>
#include <avr/io.h>
#include <avr/interrupt.h>

ISR(TIMER1_COMPA_vect)
{
	PORTC ^= (1<<PC3);		//Toggle LED1
}

int main(void)
{
	DDRC = (1<<PC3)|(1<<PC4)|(1<<PC5);		//LED's as outputs all other inputs
	PORTC = (1<<PC3)|(1<<PC4)|(1<<PC5);		//LED pins high - LED's off

	//Initialize Timer1, CTC mode, TOP OCR1A
	TCCR1A = 0;
	TCCR1B = (1<<WGM12);

	TIMSK = (1<<OCIE1A);			//Enable Timer 1 OCR1A Compare match Interrupt
	sei();

	while(1)
	{
		if((PINC & 7) == 6) 		//SW1 pressed
		{
			OCR1A = 14400;			//1Hz
			TCNT1 = 0;		
			TCCR1B |= (5<<CS10);	//Timer Start
		}
		else if ((PINC & 7) == 5) 	//SW2 pressed
		{
			OCR1A = 7200;			//0.5Hz
			TCNT1 = 0;
			TCCR1B |= (5<<CS10);	//Timer Start
		}
		else if ((PINC & 7) == 3) 	//SW3 pressed
		{
			OCR1A = 1440;			//0.1Hz
			TCNT1 = 0;
			TCCR1B |= (5<<CS10);	//Timer Start
		}
	}
}

</code>

==== Exercise 8 ====
Flashes LEDs with different frequency using timer. S1 increases flashing frequency and S3 decreases.
<code c>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>


ISR(TIMER1_COMPA_vect)
{
	PORTC ^= (1<<PC3)|(1<<PC4)|(1<<PC5); //toggle all LEDs
}

int main(void)
{
	uint16_t freq;
	
	DDRC = (1<<PC3)|(1<<PC4)|(1<<PC5);	//LED pins outputs, other inputs
	PORTC = (1<<PC3)|(1<<PC4)|(1<<PC5);	//LED's off

	//Initialize Timer1, CTC mode, F_CPU/1024 Hz,  
	TCCR1A = 0;
	TCCR1B = (1<<WGM12)|(1<<CS12)|(1<<CS10);
	OCR1A = 1000;
	freq = 1000;

	TIMSK = (1<<OCIE1A); 				//enable  COMPA interrupt
	
	sei();								//enable global interrupts

	while(1)
	{
		if((PINC & 7) == 6) 			//SW1 pressed
		{
			if (freq > 100)
				freq = OCR1A - 100;
			else
				freq = 100;
			OCR1A = freq;				//increase frequency
			TCNT1 = 0;	
		}
		else if ((PINC & 7) == 3) 		//SW3 pressed
		{
			if (freq < 20000)
				freq = OCR1A + 100;
			else
				freq = 20000;	
			
			OCR1A = freq;				//decrease frequency
			TCNT1 = 0;
		}
		_delay_ms(100);
	}
}

</code>

==== Exercise 9 ====
Counts numbers on 7-seg display from 1 to 9. If button S1 is pressed the counting starts to go backward. If S3 is pressed the counting resumes to go forward. Digit change frequency is 1 second.
<code c>
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

#define FORWARDS	0
#define BACKWARDS	1

//global variables
volatile uint8_t direction = FORWARDS;
volatile uint8_t num = 0;

//function declarations
void WriteDisplay(uint8_t);
int main();


//Timer 1 interrupt (every 1 second)
ISR(TIMER1_COMPA_vect)
{
	if((direction == FORWARDS) && (num < 9)) 		//count up until 9
		num++;
	else if ((direction == BACKWARDS) && (num > 0))	//count down until 0
		num--;
	WriteDisplay(num);
}

void WriteDisplay (uint8_t digit) 
{
	 volatile uint8_t nr;
	 switch (digit) //table read to get segment map representation of the digit
	 {
		 case 0 : {nr = 0b00111111;break;} //every bit corresponds to one segment
		 case 1 : {nr = 0b00000110;break;} //"1"
		 case 2 : {nr = 0b01011011;break;} //"2" and so on
		 case 3 : {nr = 0b01001111;break;} 
		 case 4 : {nr = 0b01100110;break;} 
		 case 5 : {nr = 0b01101101;break;} 
		 case 6 : {nr = 0b01111100;break;} 
		 case 7 : {nr = 0b00000111;break;}
		 case 8 : {nr = 0b01111111;break;} 
		 case 9 : {nr = 0b01100111;break;}  
		 default: {nr = 0b01111001;}//E
	 }

	 PORTG &= ~(1<<PG2); 				//latch low
	 for(uint8_t i=8; i>0; i--) 		//for every bit in the byte
	 {
	 	//if bit is set, sets the data out pin
		if (nr & (1<<(i-1))) 
			PORTC |= (1<<PC6); 			//serial out
		else 
			PORTC &= ~(1<<PC6); 		//serial out
 
		PORTC |= (1<<PC7); 				//clock high
		_delay_us(10);					//series of one cycle delays to ensure required timing (according to datasheet)
 
		PORTC &= ~(1<<PC7); 			//clock low
		_delay_us(10);
	 }
	 PORTG |= (1<<PG2); 				//latch high
}

int main(void)
{
	DDRC = (1<<PC3)|(1<<PC4)|(1<<PC5)|(1<<PC6)|(1<<PC7);	//declare input-outputs
	DDRG = (1<<PG2);
	
	PORTC = (1<<PC3)|(1<<PC4)|(1<<PC5); //all LED's off

	//Initialize Timer1, CTC mode, OCRA interrupt 1s 
	TCCR1A = 0;
	TCCR1B = (1<<WGM12)|(5<<CS10);

	TIMSK = (1<<OCIE1A);
	OCR1A = 14400;

	sei();

	while(1)
	{
		if((PINC & 7) == 6) 			//SW1 pressed
		{
			direction = BACKWARDS;
		}
		else if ((PINC & 7) == 3) 		//SW3 pressed
		{
			direction = FORWARDS;
		}
	}
}

</code>

~~DISCUSSION~~