Ping-Pong über LED-Brett für Anfänger

[Loramor (Gast)]

Hallo Leute,
habe seit 3 Monaten etwa Mikrocontroller im Unterricht und bin bei 
meinen recherchen auch auf das Ping-Pong Spiel gestoßen.

Ich habe da auch schon einige codes gesehen aber die versteh ich nicht 
und die sind mir leider noch zu komplex.

Wir haben gerade pwm durchgenommen und sind jetzt bei interrupts.

Ich wollte halt mal fragen ob man den Code auch vereinfachen kann?

So dass ich beispielsweise sage, bei knopf "hoch" geht immer eine LED 
aus und eine andere an damit das so aussieht als würden die balken sich 
bewegen?

dann wäre noch das Problem wie man es mit dem Ball einfacher realisieren 
kann?

Wäre cool wenn es da eine einfachere Lösung geben würde.

Mfg
Loramor

[Wegstaben V. (wegstabenverbuchsler)]

> ob man den Code auch vereinfachen kann?

welchen Code meinst du denn?

[Frank (Gast)]

ohne code gibt das keinen

[Loramor (Gast)]

ja dachte es würde so einen standard code geben.
hatte hier schon welche im forum gefunden.
ich guck mal ob ich den noch wieder finde

[Loramor (Gast)]

hier ist mal ein code

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>

#include "font.h"

int pong_mode;

/***************************************\
 * Ports:
 * A0-6: Dot matrix rows
 * D0-4: Dot matrix columns
 * B0:   Player 2 UP
 * B1:   Player 2 DOWN
 * B2:   Player 1 UP
 * B3:   Player 1 DOWN
 * B4:   Player 2 score LED
 * B5:   Player 1 score LED
 \***************************************/

/***************************************\
 * Framebuffer(5x7 dot matrix):
 * 6 x x x x O
 *   x x x x O <- p2_pos = 5
 *   x x x x x
 *   x x x x x
 *   x x x x x
 *   x x x x O
 * 0 x x x x O <- p2_pos = 0
 *   0       4
 \***************************************/

volatile unsigned char framebuffer[5];
volatile unsigned char framebuffer_pos = 0x00;

volatile char ball_x;
volatile char ball_y;
volatile char ball_dx;
volatile char ball_dy;
volatile char p1_pos; /* Position of player 1 paddle */
volatile char p2_pos; /* Position of player 2 paddle */
volatile char ballClock; /* Move ball only every to tick */
volatile char redraw_needed;
volatile char speed_counter; /* increase speed as game goes on */
const char speed_bumper = 10; /* increase speed after this many movement_timer ticks */
volatile char current_speed;
volatile char score; 
const unsigned char d1[] = {0x00, 0x10, 0x20, 0x7f, 0x00}; /* the number 1 */
const unsigned char d2[] = {0x47, 0x49, 0x49, 0x49, 0x31}; /* the number 2 */


#define BV(x) _BV(x)
#define outw(a, b) (a = (b))
#define outp(a, b) (b = (a))
#define inp(a) (a)


/* Draw paddles and ball */
void drawScene()
{
  framebuffer[0] = BV(p1_pos) | BV(p1_pos+1);
  framebuffer[1] = 0;
  framebuffer[2] = 0;
  framebuffer[3] = 0;
  framebuffer[4] = BV(p2_pos) | BV(p2_pos+1);
  framebuffer[(unsigned char)ball_x] |= BV(ball_y);
}

void variable_init(void)
{
  ball_x  = 2;
  ball_y  = 3;
  ball_dx = 1;
  ball_dy = 0;
  p1_pos = 2;
  p2_pos = 2;
  ballClock = 0;
  redraw_needed = 1;
  speed_counter = 0;
        current_speed = 3;
  outw(OCR1A,40000);
}

void ioinit(void)
{
  /* Set port C and B0-3, B6-7, to internal pullup, B4-5 output */
  outp(0x30, DDRB);
  outp(0x00, DDRC);
  outp(0xcf, PORTB);
  outp(0xff, PORTC);

  /* Set port A and D to output */
  outp(0xff, DDRA);
  outp(0xff, DDRD);

  /* Enable 8-bit counter1, running on clk speed */
  outp(BV(CS01), TCCR0);

  /* Set OCR1A as max value and Enable 16-bit counter,
   * running on clk/8 speed */
  outp(BV(WGM12)|BV(CS11), TCCR1B);
  
  /*  */
  outw(OCR1A,40000);

  /* Enable overlow when counter1 reaches OCR1A */
  /*outp(BV(TOV1), TIFR);*/

  /* Enable overflow interrupt for counter 0 and counter 1*/
  timer_enable_int(BV(TOIE0)|BV(OCIE1A));

  /* Enable interrupts */
  sei();
}

/* Switch leds to indicate who's leading */
void update_score_output(void) {
  if (score == 1) 
  {
    outp(0xef, PORTB); /* turn on led for player 1 */
  }
  else if(score == -1)
  {
    outp(0xdf, PORTB); /* turn on led for player 2 */
  }
  else
  {
    outp(0xcf, PORTB); /* turn off leds */
  }
}

void victory(void)
{
  unsigned char buttons;
  int i;
  int j;
  
  /* turn off counter */
  outp(0x00, TCCR1B);
  
  /* turn on both leds */
  /* outp(0xff, PORTB); */

  /* Display winner */
  if (score == 1) 
  {
    framebuffer[0] = d1[0];
    framebuffer[1] = d1[1];
    framebuffer[2] = d1[2];
    framebuffer[3] = d1[3];
    framebuffer[4] = d1[4];
  }
  else 
  {
    framebuffer[0] = d2[0];
    framebuffer[1] = d2[1];
    framebuffer[2] = d2[2];
    framebuffer[3] = d2[3];
    framebuffer[4] = d2[4];
  }
  sei();

        /* wait a little */
  for (i = 0; i < 5000; i++)
    for (j = 0; j < 1000; j++) j=j;
  /* wait for buttonpress to start again */
  buttons = ~inp(PINB);
  while( (buttons & 0x0f) == 0x00 ) {
    unsigned char wait_count;
    for (wait_count = 0; wait_count < 0xff; ++wait_count);
    buttons = ~inp(PINB);
  }

  cli();

  /* Reinit */
  variable_init();
  ioinit();
  score = 0;
        speed_counter = 0;
}

/* Movement */
void timer_movement(unsigned char portB)
{
  unsigned char p1_up; /* Player 1  up  button pressed */
  unsigned char p1_dn; /* Player 1 down button pressed */
  unsigned char p2_up; /* Player 2  up  button pressed */
  unsigned char p2_dn; /* Player 2 down button pressed */
  char pos;
  char loose;
  char paddle_bounce;
  int i;
  int j;

  /* Read buttons */
  p1_up = portB & 0x04; /* Pin B2 */
  p1_dn = portB & 0x08; /* Pin B3 */
  p2_up = portB & 0x01; /* Pin B0 */
  p2_dn = portB & 0x02; /* Pin B1 */

  /* Stop paddle movement at wall */
  p1_up = (p1_up && p1_pos < 5);
  p1_dn = (p1_dn && p1_pos > 0);
  p2_up = (p2_up && p2_pos < 5);
  p2_dn = (p2_dn && p2_pos > 0);

  /* Move paddles */
  if (p1_up) p1_pos++;
  if (p1_dn) p1_pos--;
  if (p2_up) p2_pos++;
  if (p2_dn) p2_pos--;

  /* Move ball only every two clock tick */
  if ((ballClock = !ballClock))
  {
    /* Bounce ball on wall */
    if (ball_y == 0) ball_dy = -ball_dy;
    if (ball_y == 6) ball_dy = -ball_dy;

    /* Bounce ball on paddle */
    loose = 0;
    paddle_bounce = 0;
    pos = (ball_x == 1)?p1_pos:p2_pos;
    if (ball_x == 1 || ball_x == 3)
    {
      loose = 1;
      if (ball_y == pos || ball_y == pos+1)
      {
        ball_dx = -ball_dx;
        loose = 0;
        paddle_bounce = 1;
      }
      else if (ball_y == pos-1 && ball_dy == 1)
      {
        ball_dx = -ball_dx;
        ball_dy = -ball_dy;
        loose = 0;
        paddle_bounce = 1;
      }
      else if (ball_y == pos+2 && ball_dy == -1)
      {
        ball_dx = -ball_dx;
        ball_dy = -ball_dy;
        loose = 0;
        paddle_bounce = 1;
      }

    }
    if (loose)
    {
      if (ball_x == 1)  /* player 2 won */
      {
        if (score == -1) /* total victory! */
        {
          victory();
          return;
        }
        else
        {
          score--;
          update_score_output();

          ball_x += ball_dx;
          ball_y += ball_dy;
          redraw_needed = 1;

          outp(0x00, TCCR1B); /* turn off counter */
          sei(); /* Re-enable interrupts */
          /* Wait a little */
          for (i = 0; i < 5000; i++)
            for (j = 0; j < 1000; j++) j=j;
          cli(); /* Disable interrupts again */
          outp(BV(WGM12)|BV(CS11), TCCR1B); /* turn on counter */
        }
      }
      else { /* player 1 won */
        if (score == 1) /* total victory! */
        {
          victory();
          return;
        }
        else
        {
          score++;
          update_score_output();

          ball_x += ball_dx;
          ball_y += ball_dy;
          redraw_needed = 1;

          outp(0x00, TCCR1B); /* turn off counter */
          sei(); /* Re-enable interrupts */
          /* Wait a little */
          for (i = 0; i < 5000; i++)
            for (j = 0; j < 1000; j++) j=j;
          cli(); /* Disable interrupts again */
          outp(BV(WGM12)|BV(CS11), TCCR1B); /* turn on counter */
        }
      }
      variable_init();
      update_score_output();
    }

    /* Change vertical speed of ball according to paddle speed */
    if (paddle_bounce)
    {
      if (ball_x == 1 && p1_up && ball_dy <  1) ball_dy++;
      if (ball_x == 1 && p1_dn && ball_dy > -1) ball_dy--;
      if (ball_x == 3 && p2_up && ball_dy <  1) ball_dy++;
      if (ball_x == 3 && p2_dn && ball_dy > -1) ball_dy--;
    }

    /* Wall bounce after paddle bounce */
    if (ball_y == 0 && ball_dy == -1) ball_dy = -ball_dy;
    if (ball_y == 6 && ball_dy ==  1) ball_dy = -ball_dy;

    /* Move ball */
    ball_x += ball_dx;
    ball_y += ball_dy;
  }

  redraw_needed = 1;
}

/* Framebuffer output to led matrix */
SIGNAL(SIG_OVERFLOW0)
{
  if (++framebuffer_pos > 4) framebuffer_pos = 0;

  /* Change output to dot matrix */
  outp(0xff, PORTA); /* Avoid ghosting */
  outp(BV(framebuffer_pos), PORTD);
  outp(~framebuffer[framebuffer_pos], PORTA);

  if (!pong_mode) return;
  /* Redraw scene during "vertical retrace" */
  if (framebuffer_pos == 4 && redraw_needed)
  {
    drawScene();
    redraw_needed = 0;
  }
}

/* Movement */
SIGNAL(SIG_OUTPUT_COMPARE1A)
{
  if (!pong_mode) return;
  if (++speed_counter == speed_bumper) {
    speed_counter = 0;
    outw(OCR1A, (40000 / ++current_speed) * 3);
    if (current_speed > 100) current_speed = 100;
  }

  timer_movement(~inp(PINB));
}

int main_pong(void)
{
  score = 0;
  variable_init();
  ioinit();
  for(;;);
}

int main_font(void)
{
  unsigned char portB;
  unsigned char nextPressed;
  unsigned char prevPressed;
  int cf; /* Current font */

  nextPressed = 0;
  prevPressed = 0;
  cf = 0;
  framebuffer[0] = font[cf][0];
  framebuffer[1] = font[cf][1];
  framebuffer[2] = font[cf][2];
  framebuffer[3] = font[cf][3];
  framebuffer[4] = font[cf][4];

  ioinit();

  for(;;)
  {
    portB = ~inp(PINB);

    /* Prev button */
    if (portB & 0x01)
    {
      if (!prevPressed)
      {
        cf--;
        if (cf < 0) cf = 0;
        framebuffer[0] = font[cf][0];
        framebuffer[1] = font[cf][1];
        framebuffer[2] = font[cf][2];
        framebuffer[3] = font[cf][3];
        framebuffer[4] = font[cf][4];
      }
      prevPressed = 1;
    }
    else
      prevPressed = 0;

    /* Next button */
    if (portB & 0x02)
    {
      if (!nextPressed)
      {
        cf++;
        if (cf >= font_count) cf = font_count - 1;
        framebuffer[0] = font[cf][0];
        framebuffer[1] = font[cf][1];
        framebuffer[2] = font[cf][2];
        framebuffer[3] = font[cf][3];
        framebuffer[4] = font[cf][4];
      }
      nextPressed = 1;
    }
    else
      nextPressed = 0;
  }
}

int main(void)
{
  unsigned char portB;
        
        framebuffer[0] = 0;
        framebuffer[1] = 0;
        framebuffer[2] = 0;
        framebuffer[3] = 0;
        framebuffer[4] = 0;
  pong_mode = 0;
        ioinit();
        
        for (;;)
        {
          portB = ~inp(PINB);
          if (portB & 0x01) {pong_mode = 1; main_pong();}
          if (portB & 0x02) {pong_mode = 0; main_font();}
        }
}

[Loramor (Gast)]

aber ist halt nicht von mir sondern nur ne beispiel.

würde gerne selber sowas machen und dann am besten in einfach. ;)

[Loramor (Gast)]

es gibt das ganze auch von conrad zu kaufen mit nem atmega8 vielleicht 
hat davon ja auch jemand den code und kann den hier mal posten 
vielleicht ist der ja schon einfacher.

[Peter II (Gast)]

Loramor schrieb:
> vielleicht ist der ja schon einfacher.

glaubst du wirklich das sich jemand die mühe gemacht hat möglichst 
komplizierten code zu schreiben?
Wenn am ende die gleichen Funktionen bereitstehen soll, dann wird wohl 
fast die gleiche code menge enstehen.

Dann fang doch einfach mal selber an zu programmmiern, dann sieht du 
schon wie viel code man dafür braucht.

[Harald W. (wilhelms)]

Loramor schrieb:
> Hallo Leute,
> habe seit 3 Monaten etwa Mikrocontroller im Unterricht und bin bei
> meinen recherchen auch auf das Ping-Pong Spiel gestoßen.

Ich nehme an, Du meinst dieses hier:
http://www.elo-web.de/elo/entwicklung-und-projekte/ping-pong
Da solltest Du mal auf den ELO-Seiten suchen. Es gibt da ne Menge Infos.

> Ich habe da auch schon einige codes gesehen aber die versteh ich nicht
> und die sind mir leider noch zu komplex.

Nun, Assemblercode ist auch anfänglich etwas unübersichtlich.
Je mehr man sich damit beschäftigt, desto klarer wird es aber.
Man sollte sich natürlich anfänglich nicht mit einem so kompli-
ziertem Programm wie dem PingPong beschäftigen. Es reicht, wenn
man eine einzelne LED zum Blinken kriegt. :-)

> Ich wollte halt mal fragen ob man den Code auch vereinfachen kann?

Eher nicht; denn dann würde man es auch von vornherein einfacher
schreiben.

> So dass ich beispielsweise sage, bei knopf "hoch" geht immer eine LED
> aus und eine andere an damit das so aussieht als würden die balken sich
> bewegen?

Nun grundsätzlich wird es in einer Hochsprache Wie "Basic" oder "C"
schon etwas einfacher. Solche Befehle, wie Du sie gerne hättest, sind
da aber auch nicht drin, denn eine Programmiersprache soll ja möglichst
universell sein.

> dann wäre noch das Problem wie man es mit dem Ball einfacher realisieren
> kann?
>
> Wäre cool wenn es da eine einfachere Lösung geben würde.

Man macht solche Sachen ja nicht, um es anderen besonders schwer
zu machen (Ausnahmen bestätigen die Regel), sondern weil für eine
bestimmte Problemlösung einfach ein gewisser Aufwand nötig ist.
Deshalb sucht man sich für den Anfang eher einfachere Probleme aus
und arbeitet sich langsam hoch. Oder habt Ihr im Mathematikunter-
richt als erstes die Differentialgleichungen gelernt, bevor ihr
zusammenzählen und abziehen konntet? :-)
Gruss
Harald

[dave_chappelle (Gast)]

Also ich würd auch eher mal klein anfangen.. Wenn du nicht mal eine 
Vorstellung davon hast, wie du einen Balken per Knopfdruck auf und ab 
bewegen kannst, dann machst du lieber erst mal etwas einfacheres.

Wenn du ein Pong willst, wie das von Conrad, dann wird der Code min. so 
gross wie der von dir gepostete. Wenn nicht sogar grösser.

Aber nicht verzagen, beginn doch einfach mal mit den grundsätzlichen 
Sachen z.B. den Balken. Stichwort bit schieben (in C sind lautet der 
Befehl dafür << und >>)..

Und wenn du einen ungefähren Lösungsansatz hast, kannst du ja wieder 
fragen.

[Loramor (Gast)]

alles klar!

danke euch!

ich fang dann mal mit den Balken an und poste meine Fortschritte hier 
mal.

Gruß
Loramor

[Loramor (Gast)]

Hab das mir das jetzt so überlegt mit dem Balken.
Also die LEDs auf der rechten Seite sind von unten nach oben LED1...LED7

if (PIND & (1<<PD2){ //Taster für hoch
PORTD |= (1<<LED1);
PORTD |= (1<<LED2);
PORTD |= (1<<LED3);
_delay_ms(100);
PORTD |= (1<<LED2);
PORTD |= (1<<LED3);
PORTD |= (1<<LED4);
_delay_ms(100);
...
}

aber was ist denn wenn ich jetzt ne Taster für runter drücke?
Dann muss ich das ja irgendwie abfragen wo er gerade steht damit ich das 
gleiche dann in die andere Richtung machen kann.

Gruß
Loramor

[Peter II (Gast)]

Loramor schrieb:
> Dann muss ich das ja irgendwie abfragen wo er gerade steht damit ich das
> gleiche dann in die andere Richtung machen kann.

Du musst bei dir die logik von der ausgabe trennen. Du brauchbt also 
eine Variable wo die Position gespeichert wird. Dann braucht du eine 
Ausgabefunktion die anhängig von der Position die ausgabe macht. Dann 
noch ein funktion die die Tasten übewacht und abhängig von der Taste die 
position ändert.

Außerdem gehen bei deinen code die LEDS nie aus.

[Loramor (Gast)]

dann könnte ich das ja mit ner case funktion realisieren.

wenn ich die Taste drücke wird ne Variable hochgezählt und diese 
Variable gibt dann an über case, welche LEDs dann leuchten.

So müsste das ja realisierbar sein denke ich.

[Loramor (Gast)]

Hallo zusammen,
hab jetzt mal den Schaltplan und das bisher bestehende Programm 
hochgeladen.

Die Balken kann ich jetzt beide über jeweils 2 Taster steuern.
Im Programm ist im Moment nur 1 Balken programmiert, der andere Balken 
kommt noch.
Dafür klemm ich die letzte LED-Reihe ab, damit ich an dem Anschluss noch 
einen 4. Taster anklemmen kann.

Jetzt ist aber das nächste und wahrscheinlich auch größte Problem wie 
ich das mit dem Ball mache.

- Also die Abfrage ob er die Platte getroffen hat oder nicht.
- Dann die Bewegung die der Ball macht wenn er die Platte getroffen hat.
- und wo er wieder auftaucht wenn er die Platte nicht getroffen hat.

Hat da einer ne Idee oder kann mir jemand einen Denkanstoß geben?

Mit freundlichem Gruß
Loramor

[Clemens M. (panko)]

Den Ball hat eine konstante Geschwindigkeit denke ich?
Dann kannst du anhand seines Geschwindigkeitsvektors ja direkt 
ausrechnen, ob der beim nächsten Zeitschritt ein Hindernis trifft. 
Einfach gucken ob die Position erlaubt ist.
Am Paddel gilt dann Einfallswinkel gleich Ausfallswinkel. Wobei ich 
-meine- mich zu erinnern, daß die Enden anderes Verhalten zeigten beim 
Pong.

Funktioniert denn die Ansteuerung deiner Matrix und die Steuereingabe 
zufriedenstellend?

[Loramor (Gast)]

Ja der soll eine Geschwindigkeit beibehalten.

Zufriedenstellend noch nicht ganz.
Ich musste die LEDs gegeneinander Verriegeln und das hab ich über 
schnelles Blinken realisiert und wenn man jetzt die Knöpfe drückt geht 
immer eine Seite kurz aus.
Denke das liegt am Atmega8 und das er vielleicht nicht mehr schafft.

Aber kannst du mir das mit dem Ball noch ne bisschen genauer beschreiben 
steh da gerade noch aufm Schlauch sun bisschen.

[Peter II (Gast)]

Loramor schrieb:
> Denke das liegt am Atmega8 und das er vielleicht nicht mehr schafft.

ganz bestimmt nicht.


Du hast _delay_ms(200); im code drin, damit bekommst du keine saubere 
anzeige hin.

[Erich (Gast)]

Ein  _delay_ms( <egalwieviel> )
hat in einem ordentlichen Programm  n i c h t s  zu suchen,
kommt also überhaupt nicht vor.
Das macht man mit Timer und Interrupt.

Insofern siehst du mal, was das am Threadanfang von dir reinkopierte 
Programm schon alles kann,
und was du jetzt mühsam hinpfriemeln willst.

[Clemens M. (panko)]

Zunächst würde ich definitiv an der Ansteuerung der Led Matrix 
weiterarbeiten.
Denn früher oder später muss etwas 2-dimensionales angezeigt werden.
Es sollte möglich sein etwas oberhalb des Panels anzuzeigen. Evtl. wäre 
auch ein Sichten des wiki Artikels hilfreich.

Bin selber kein heldenhafter Programmierer, aber da fehlt nach meinem 
Gefühl Konzept in deinem Code was überhaupt passieren soll. Also nicht 
verzagen.

Zum Ball. Da wirst du dir sicherlich die aktuelle Position und aktuelle 
Geschwindikeit merken. Also pos als (x,y) und geschw als (vx,vy). 
Vermute ich mal.
Beim nächsten Zeitschritt (eine Zeitbasis braucht das Programm noch) 
haste dann halt pos (x+vx*dt, y+vy*dt) und wenn das außerhalb des Feldes 
wäre, hast du verloren.
Bei einer Reflexion ändert sich ann die Geschwindigkeitskomponente je 
nach Einschalgsszenario.

[Clemens M. (panko)]

P.S. das was im Beispielcode oben framebuffer genannt wird, macht Sinn. 
Da kannst du virtuell das Paddel verschieben, den Ball bewegen usw.
Eine Routine zeigt dir den Inhalt des framebuffers dann auf den leds an.

Also wäre das Beste, zunächst zu versuchen einen framebuffer auf der 
Matrix darszustellen. Ein 2d Array, was z.B. einen Buchstaben fest 
eingetütet enthält.
Vielleicht liest auch einer der Altvorderen hier mal rein, bei konkreten 
Problemen zu dem Problem können sie sicher helfen.

[Thorsten S. (whitejack) (Gast)]

Hey Loramor,

nimm doch die Schaltung des original Pong Spiels:

http://www.produktinfo.conrad.com/datenblaetter/900000-924999/902766-an-01-ml-CONRAD_RETRO_SPIEL_PING_PONG_de_en_fr_nl.pdf

Seite 15.

http://www.conrad.de/ce/de/product/902766/CONRAD-RETRO-SPIEL-PING-PONG

Dann kannst du die ISR aus dem Netz ziehen die die Matrix im Ram des 
Controllers spiegelt, das ist ein flotter 8 Zeiler...

Damit hast du eine solide Basis für alle Matrix Anwendungen.

Gruß,
T

[Loramor (Gast)]

Danke für die ganzen Antworten.

Erich kannst du mir mal ne Beispiel für sun Timer schreiben oder zeigen.
Kenn die sonst nur von PWM wenn das das ist was ich meine.

Gruß
Loramor

[Erich (Gast)]

GOOGLE kann auch dein Freund werden:
    avr timer interrupt

Ergebnisse zu hauf, z.B.
http://www.rn-wissen.de/index.php/Timer/Counter_%28Avr%29

[Christian H. (christian_h)]

Zeig doch mal Eigeninitiative. Nur wenige Zentimeter von deiner Maus 
entfernt, befindet sich übrigens ein schönes Tutorial zu AVR, aber wer 
suchet der findet.

[Zeigefinger (Gast)]

Das avr Tutorial ist ein guter Rat. Du hast ja definitiv noch viele 
Lücken. Da kann ich nur raten: mach nicht alles auf einmal, wiederhole 
auch (vermeintlich) bekannte Dinge.
Zu viel auf einmal geht hier nicht und du kannst nun mal nicht erwarten, 
daß du so ein relativ komplexes Projekt nach einem Beispiel in der 
Schule stemmen kannst.
Also ran ans Tutorial und üben, alles mögliche blinken lassen usw. Du 
hast Glück daß der Thread noch intakt ist und nicht zertrollt wurde.
Richtig glücklich wirst du auch nicht wenn du etwas vorgekaut bekommst. 
Das wär ja Schule vor ner Klausur :P


-such das avr Tutorial.
-gucks dir an auch wenn der Anfang dir bekannt vorkommt.
-als Anfang solltest du versuchen den ganz schnöden OVERFLOW interrupt 
zu verwenden. Da musst du nämlich quasi nichts machen.
Da lässt du in der isr z.B. ne led laufen oder setzt dir ein flg für das 
Hauptprogramm oder was auch immer. Probieren und inspirieren lassen. ocr 
oder andere Modi kommen so oder so danach
-dann ein 1D Paddel nur mit der Led zeile. Noch nix multiplexen. Nur das 
Paddel in einer Dimension bewegen können. Bei deiner Tasteneingabe ist 
nämlich auch noch nicht alles super. Stichwort Entprellen und ggf. auch 
Beschleunigung für die Bewegung.

usw. Da werden einige Aha Momente kommen und der Schule tuts auch gut. 
Wenn was nicht klappt, also gar nicht klappt nach Stunden. Fragen. Bugs 
suchen ist natürlich als Anfänger besonders schwierig.