/*****************************************************
Compiler : CodeVisionAVR 2.04.6 Evaluation
Chip type : ATmega8
Clock frequency : 8 MHz (int. RC-OSC)
*****************************************************/

//***************************************************
// Festtagsmusik
// auf Basis des Franzis-Pingpong
// http://www.elo-web.de/ping-pong-start
//***************************************************

#include <mega8.h>
#include <stdio.h>
#include <delay.h>
#include <sleep.h>

#define P_CLK PORTB.3
#define P_DATA PORTB.4
#define P_STROBE PORTB.2

#define PIN_COIN PIND.2
#define PULLUP_COIN PORTD.2
#define DIR_COIN DDRD.2
#define COIN_INSERTED (PIN_COIN == 0)

#define PIN_KEY PIND.3
#define PULLUP_KEY PORTD.3
#define KEY_PRESSED (PIN_KEY == 0)

#define P_PLAY PORTC.4 // Portpin for "Play/Pause" of MP3 player
#define DP_PLAY DDRC.4
#define P_FWD PORTC.5 // Portpin for "Forward" of MP3 player
#define DP_FWD DDRC.5

#define WIDTH 12 // number of fields in horizontal direction
#define HEIGHT 10 // number of fields in vertical direction
unsigned int leds[WIDTH]; // current state of each LED (organized in columns)
unsigned int ledsBlink[WIDTH]; // current blink state of each LED (organized in columns)

unsigned int iRecordTime = 0;
bit bRecordTime = 0; // 1 = record time
eeprom unsigned int eeTime[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // recorded time for each song stored in EPPROM

flash unsigned char decimals[] =
{
0x1F, 0x11, 0x1F, // 0
0x04, 0x02, 0x1F, // 1
0x1D, 0x15, 0x17, // 2
0x15, 0x15, 0x1F, // 3
0x07, 0x04, 0x1F, // 4
0x17, 0x15, 0x1D, // 5
0x1F, 0x15, 0x1D, // 6
0x01, 0x01, 0x1F, // 7
0x1F, 0x15, 0x1F, // 8
0x17, 0x15, 0x1f, // 9
0x04, 0x04, 0x04 // -
};

flash unsigned char celebration[] =
{
0x3E,0x51,0x49,0x45,0x3E, // 0
0x00,0x42,0x7F,0x40,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
0x3C,0x4A,0x49,0x49,0x30, // 6
0x01,0x71,0x09,0x05,0x03, // 7
0x36,0x49,0x49,0x49,0x36, // 8
0x06,0x49,0x49,0x29,0x1E, // 9
0x3E,0x41,0x41,0x41,0x3E, // O (Ostern)
0x3E,0x41,0x49,0x49,0x3A, // G (Geburtstag)
0x7F,0x20,0x10,0x20,0x7F // W (Weihnachten)
};

flash unsigned char celeb[] = { 'O', 'G', 'W' };

flash unsigned int christmastree[] =
{
0x0080,
0x00D0,
0x00B8,
0x0094,
0x0382,
0x0001,
0x0382,
0x0094,
0x00B8,
0x00D0,
0x0080,
0x0000
};

flash unsigned int birthdaygift[] =
{
0x03F8,
0x03FB,
0x031D,
0x031E,
0x0318,
0x03F8,
0x0318,
0x031E,
0x031D,
0x03FB,
0x03F8,
0x0000
};

flash unsigned int easterbunny[] =
{
0x03E0,
0x001F,
0x0309,
0x00AE,
0x01A8,
0x0388,
0x01A8,
0x00AE,
0x0309,
0x001F,
0x03E0,
0x0000
};

// clear the whole screen, all LEDs off
void clearScreen(void)
{
unsigned char i;

for(i = 0; i < (WIDTH); i++)
{
leds[i] = 0;
}
}

// wait until key is pressed
void waitUntilKeypressed(void)
{
while(!KEY_PRESSED);
delay_ms(20);
}

// wait until key is released
void waitUntilKeyreleased(void)
{
while(KEY_PRESSED);
delay_ms(20);
}

// check if key is pressed
// return: 0=key not pressed, 1=key pressed
unsigned char keyPressed(void)
{
unsigned char result = 0;

if(KEY_PRESSED)
result = 1;
delay_ms(20);

return result;
}

// Timer 2 overflow interrupt service routine
// multiplexing of LEDs
// approx. every 1ms
interrupt [TIM2_OVF] void timer2_ovf_isr(void)
{
static unsigned char count = 0;
unsigned char cValue, cValue2;
static unsigned char cBlink = 0x00;
static unsigned char cBlinkcnt = 0;
static unsigned char cRec100ms = 0;

cBlinkcnt++;
if(cBlinkcnt >= 250)
{
cBlinkcnt = 0;
cBlink = ~cBlink;
}

if(bRecordTime)
{
cRec100ms++;
if(cRec100ms >= 100)
{
cRec100ms = 0;
iRecordTime++;
}
}
else
{
cRec100ms = 0;
}

count++;
if(count >= 12)
{
count = 0;
P_DATA = 0;
}
else
{
P_DATA = 1;
}
P_CLK = 1;
P_CLK = 0;
PORTC &= (~0x0F);
PORTD &= (~0xF0);
PORTB &= (~0x03);
P_STROBE = 1;
P_STROBE = 0;
cValue = (unsigned char)leds[count] & 0x0F;
cValue2 = (unsigned char)ledsBlink[count] & cBlink;
cValue &= (~cValue2);
PORTC |= cValue;
cValue = (unsigned char)leds[count] & 0xF0;
cValue &= (~cValue2);
PORTD |= cValue;
cValue = (unsigned char)(leds[count]>>8) & 0x03;
cValue2 = (unsigned char)(ledsBlink[count]>>8) & cBlink;
cValue &= (~cValue2);
PORTB |= cValue;
}

// initialization of Timer2
void initTimer2(void)
{
// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: 250,000 kHz
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x03;
TCNT2=0x00;
OCR2=0x00;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x40;
}

// set controller in Powerdown mode
void setStandbyMode(void)
{
TCCR2 &= 0xF8; //stop Timer2
PORTC = 0;
PORTD = 0;
PORTB = 0;
ADCSRA &= 0x7F; // stopADC
DDRD.2 = 0;
PORTD.2 = 1;
GICR |= 0x40; //enable INT0
sleep_enable();
powerdown();
GICR &= (~0x40); //disable INT0
PULLUP_KEY = 1;
DDRD.2 = 1;
PORTD.2 = 0;
ADCSRA |= 0x80; //startADC
TCCR2 |= 0x03; //start Timer2
}

// External Interrupt 0 service routine
interrupt [EXT_INT0] void ext_int0_isr(void)
{
}

// initialization of INT0
void initInt0(void)
{
// External Interrupt(s) initialization
// INT0: disabled
// INT0 Mode: Low level
GICR &= (~0x40); //disable INT0
MCUCR &= 0xFC;
GIFR=0x40;
}

// initialization of ports
void init(void)
{
PORTB = 0;
DDRB = 0x1F;
PORTC = 0;
DDRC = 0x0F;
PORTD = 0;
DDRD = 0xF4;
PULLUP_KEY = 1;
P_PLAY = 0;
DP_PLAY = 1;
P_FWD = 0;
DP_FWD = 1;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
SFIOR=0x00;
}

// display a decimal value
// x: decimal value (0..999)
// row: row to begin displaying value
// col: column to begin displaying value
void showDecimal(unsigned int x, unsigned char row, unsigned char col)
{
unsigned char i, j, value, divisor;

x %= 1000;
divisor = 100;
for(i = 0; i < 3; i++)
{
value = x / divisor;
for(j = 0; j < 3; j++)
{ // show decimal using stored font
leds[col++] = ((unsigned int)decimals[value*3 + j] << row);
}
leds[col++] = 0;
x = x % divisor;
divisor /= 10;
}
}

// display a char for celebration
// x: char ('0'..'9', 'O', 'G', 'W')
// row: row to begin displaying value
// col: column to begin displaying value
void showCelebrationChar(unsigned char x, unsigned char row, unsigned char col)
{
unsigned char value, j;

if(x == 'O')
value = 10;
else if(x == 'G')
value = 11;
else if(x == 'W')
value = 12;
else
value = x - '0';
for(j = 0; j < 5; j++)
{ // show char using stored font
leds[col++] = ((unsigned int)celebration[value*5 + j] << row);
}
}

#define ADC_VREF_TYPE 0x00

// initialization of ADC
void initADC(void)
{
// ADC initialization
// ADC Clock frequency: 125,000 kHz
// ADC Voltage Reference: AREF pin
ADMUX=ADC_VREF_TYPE & 0xff;
ADCSRA=0x86;
}

// Read the AD conversion result
// adc_input: ADC channel (0..7)
// return: ADC value (0..1023)
unsigned int read_adc(unsigned char adc_input)
{
ADMUX=adc_input | (ADC_VREF_TYPE & 0xff);
// Delay needed for the stabilization of the ADC input voltage
delay_us(10);
// Start the AD conversion
ADCSRA|=0x40;
// Wait for the AD conversion to complete
while ((ADCSRA & 0x10)==0);
ADCSRA|=0x10;

return ADCW;
}

// select song to be played
// return: selected song number (0...2)
unsigned char selectSong(void)
{
unsigned char x;

x = 2 - (read_adc(7) / (1023/3 + 1));

return(x);
}

// select celebration
// return: selected value (0=easter, 1=birthday, 2=christmas)
unsigned char selectCelebration(void)
{
unsigned char x;

x = (read_adc(6) / 342);

return(x);
}

#define DELAY_KEY 100
#define DELAY_NEXTKEY 100

// power-on command for MP3 player
void mp3_powerOn(void)
{
P_PLAY = 1;
delay_ms(3000); // power on delay
P_PLAY = 0;
delay_ms(500);
}

// power-off command for MP3 player
void mp3_powerOff(void)
{
P_PLAY = 1;
delay_ms(3000); // power off delay
P_PLAY = 0;
delay_ms(DELAY_NEXTKEY);
}

// play command for MP3 player
void mp3_play(void)
{
P_PLAY = 1;
delay_ms(DELAY_KEY);
P_PLAY = 0;
delay_ms(DELAY_NEXTKEY);
}

// pause command for MP3 player
void mp3_pause(void)
{
P_PLAY = 1; // Pause
delay_ms(DELAY_KEY);
P_PLAY = 0;
delay_ms(300);
}

// forward command for MP3 player
void mp3_forward(unsigned char x)
{
unsigned char i;

for(i = 0; i < x; i++)
{
P_FWD = 1;
delay_ms(DELAY_KEY);
P_FWD = 0;
delay_ms(DELAY_NEXTKEY);
}
}

// show a logo on LED display
// pLogo: pointer to logo
void showLogo(flash unsigned int *pLogo)
{
unsigned char i;

for(i = 0; i < 12; i++)
{
leds[i] = *pLogo++;
}
}

// switch on blinking for all LEDs
void blinkOn(void)
{
unsigned char i;

for(i = 0; i < 12; i++)
ledsBlink[i] = 0xFFFF;
}

// switch off blinking for all LEDs
void blinkOff(void)
{
unsigned char i;

for(i = 0; i < 12; i++)
ledsBlink[i] = 0;
}

// main routine
void main(void)
{
unsigned char c, s, index;
unsigned int t, iTime;
bit bSetup = 0;

init();

if(keyPressed())
{ // if keypressed at poweron => setup play times
bSetup = 1;
}

initTimer2();
initADC();
initInt0();

clearScreen();

#asm("sei") // Global enable interrupts

if(bSetup)
{ // if keypressed at poweron => setup play times
while(1)
{
s = selectSong(); // read selected song
c = selectCelebration(); // read selected celebration category
showCelebrationChar(celeb[c], 1, 0);
showCelebrationChar(s+1+'0', 1, 6);
if(bSetup)
{
waitUntilKeyreleased();
bSetup = 0;
}
if(keyPressed())
{
waitUntilKeyreleased();
clearScreen();
showDecimal(0, 2, 0);
index = c*3 + s;
mp3_powerOn(); // "power on"
if(index == 0) // if first song then "play"
{
mp3_play();
}
else // else "forward" to selected song
{
mp3_forward(index);
}
iRecordTime = 0;
bRecordTime = 1; // start record time
do
{
t = iRecordTime;
showDecimal(t/10, 2, 0); // show recorded time approximately in seconds
}
while(!keyPressed()); // until key is pressed

bRecordTime = 0; // stop record time
mp3_pause(); // "pause"
mp3_powerOff(); // "power off"
bSetup = 1;
eeTime[index] = iRecordTime; // store recorded time to EEPROM
delay_ms(4000); // wait until MP3 player is powered off
clearScreen();
}
}
}

while(1)
{
clearScreen();
s = selectSong(); // read selected song
c = selectCelebration(); // read selected celebration category
showCelebrationChar(celeb[c], 1, 0);
showCelebrationChar(s+1+'0', 1, 6);
delay_ms(1000);

if(c == 0) // show logo for selected celebration
showLogo(easterbunny);
else if(c == 1)
showLogo(birthdaygift);
else
showLogo(christmastree);
blinkOn();

index = c*3 + s;
mp3_powerOn(); // "power on"
if(index == 0) // if first song then "play"
{
mp3_play();
}
else // else "forward" to selected song
{
mp3_forward(index);
}

iRecordTime = 0;
bRecordTime = 1;
iTime = eeTime[index];
blinkOff();

do // loop until song is terminated
{
t = iRecordTime;
if(keyPressed())
{
waitUntilKeyreleased();
break;
}
}
while(t < iTime);
mp3_pause(); // "pause"
blinkOn();
mp3_powerOff(); // "power off"
bRecordTime = 0;
delay_ms(4000); // wait until MP3 player is powered off
blinkOff();
clearScreen();

setStandbyMode();
}
}