/home/christian/Desktop/C_Sachen/AVR/pms/pong.c

gehe zur Dokumentation dieser Datei

#ifndef F_CPU

#define F_CPU 1000000
#endif

#define SCK PB4

#define OCK PB3

#define DS PB1

#define STATIC 0

#define SCROLLING 1

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

void clock_serial();
void clock_output();
void shift_high();
void shift_low();
void output(uint8_t*,uint8_t);
void matrix_output();
void matrix_screen_pixel(uint32_t);

void adc_init();
void get_adcval(uint16_t *);
uint8_t getkey();

void timer_init();

void clear_screen();
void start_game();
void game_failed();
void output_game();
void cursor_a_down();
void cursor_a_up();
void cursor_b_down();
void cursor_b_up();

void next_r_ball();
uint8_t check_ball_coll();

uint32_t rand();

void output_text(char*,uint8_t);

 uint8_t friendly_sm[5] PROGMEM = {0x0C,0x12,0x0,0x12,0x0};
 uint8_t unfriendly_sm[5] PROGMEM = {0x12,0x0C,0x0,0x12,0x0};
 uint8_t ansi[38][5] PROGMEM = {
                            {0x12,0x12,0x1E,0x12,0x0C}, //A
                            {0x0E,0x12,0x0E,0x12,0x0E}, //B
                            {0x0C,0x02,0x02,0x02,0x0C}, //C
                            {0x0E,0x12,0x12,0x12,0x0E}, //D
                            {0x0E,0x02,0x0E,0x02,0x0E}, //E
                            {0x0E,0x02,0x0E,0x02,0x02}, //F
                            {0x1C,0x12,0x1A,0x02,0x1C}, //G
                            {0x12,0x12,0x1E,0x12,0x12}, //H
                            {0x0E,0x04,0x04,0x04,0x0E}, //I
                            {0x06,0x08,0x08,0x08,0x0E}, //J
                            {0x12,0x0A,0x06,0x0A,0x12}, //K
                            {0x0E,0x02,0x02,0x02,0x02}, //L
                            {0x12,0x12,0x12,0x1E,0x12}, //M 
                            {0x22,0x32,0x2A,0x26,0x22}, //N
                            {0x0C,0x12,0x12,0x12,0x0C}, //O
                            {0x04,0x04,0x1C,0x14,0x0C}, //P
                            {0x14,0x0A,0x12,0x12,0x0C}, //Q
                            {0x14,0x14,0x0C,0x14,0x0C}, //R
                            {0x1C,0x10,0x08,0x04,0x1C}, //S
                            {0x08,0x08,0x08,0x08,0x1C}, //T
                            {0x1C,0x14,0x14,0x14,0x14}, //U
                            {0x08,0x14,0x14,0x14,0x14}, //V
                            {0x14,0x2A,0x2A,0x22,0x22}, //W
                            {0x22,0x14,0x08,0x14,0x22}, //X
                            {0x08,0x08,0x08,0x14,0x22}, //Y
                            {0x1E,0x04,0x08,0x10,0x1E}, //Z
                            {0x0E,0x0A,0x0A,0x0A,0x0E}, //0
                            {0x1C,0x08,0x08,0x0C,0x08}, //1
                            {0x1E,0x04,0x08,0x12,0x0C}, //2
                            {0x0C,0x12,0x08,0x10,0x1E}, //3
                            {0x08,0x08,0x0E,0x0A,0x0A}, //4
                            {0x0E,0x08,0x0E,0x02,0x0E}, //5
                            {0x0E,0x0A,0x0E,0x02,0x0E}, //6
                            {0x08,0x08,0x0A,0x0A,0x0E}, //7
                            {0x0E,0x0A,0x0E,0x0A,0x0E}, //8
                            {0x0E,0x08,0x0E,0x0A,0x0E}, //9
                            {0x00,0x40,0x00,0x40,0x00}, //:
                            {0x00,0x00,0x00,0x00,0x00}}; //
                            

 uint8_t cursor_a[5] = {0x0,0x1,0x1,0x0,0x0};
 uint8_t cursor_b[5] = {0x0,0x00,0x40,0x40,0x00};
 uint8_t ball[5] = {0x0,0x0,0x4,0x0,0x0};

 uint8_t screen_buffer_first[5];
 uint8_t screen_buffer_second[5];

volatile uint8_t ball_dir = 0;
volatile uint16_t ball_timer = 0;
 uint8_t rand_timer = 0;
 uint8_t game_running = 0;
volatile uint8_t game_failed_var = 0x0;
uint8_t points_a = 0;
uint8_t points_b = 0;


int main() {
  uint8_t key = 0;
  DDRB = (1 << PB0) | (1 << PB1)| (1 << PB3) | (1 << PB4);
  
  adc_init();
  timer_init();
  sei();
  
  clear_screen();
  output_text("PONG",SCROLLING);
  start_game();

  while(1) {
   key = getkey();
   if(game_failed_var == 0x1 || game_failed_var == 0x2) game_failed();
   switch(key) {
     case 1: cursor_a_down(); break;
     case 2: cursor_a_up(); break;
     case 3: cursor_b_down(); break;
     case 4: cursor_b_up(); break;
     default: break;
   }
  }
return 0;
}


void clock_serial() {
  PORTB |= (1 << SCK);
  PORTB &= ~(1 << SCK);
}


void clock_output() {
  PORTB |= (1 << OCK);
  PORTB &= ~(1 << OCK);
}


void shift_high() {
  PORTB |= (1 << DS);
  clock_serial();
}


void shift_low() {
  PORTB &= ~(1 << DS);
  clock_serial();
}


void output(uint8_t* in, uint8_t screen) {
 uint8_t i = 0;
 switch(screen) {
   case 1: for(i = 0; i < 5; i++) screen_buffer_first[i] = in[i]; break;
   case 2: for(i = 0; i < 5; i++) screen_buffer_second[i] = in[i]; break;
   default: break;
 }
}


void matrix_output() {
  uint8_t k,i,j,col,row = 0;
  uint32_t out = 0;
      
  for(k = 0; k < 2; k++){ //F&uuml;r beide Punktmatrix
    for(i = 0; i < 5; i++) { //Jede Spalte muss auf Punkte &uuml;berpr&uuml;ft werden
          if(k == 0) row = screen_buffer_second[i]; //Erst die rechte Punktmatrix
          else row = screen_buffer_first[i]; //Dann die linke Punktmatrix
          for(j = 0; j < 7; j++) { //Dann wird jede Zeile auf ein Punkt &uuml;berpr&uuml;ft
            if(row & 0x01) { //Wurde einer gefunden,
              out = (1 << j); //muss die jeweilige Zeile aktiviert werden
              out <<=5; //(Die Zeilen stehen in der Ausgabe 5 Bits weiter
              out |= (1 << i); //und es muss die jeweilige Spalte aktiviert werden
              out <<=1; //Welche erst ab Bit 1 anfangen
              if(k == 1) out <<= 16; //F&uuml;r den linken Bildschirm muss das Ganze 16 Bits verschoben werden (aufgrund der Schieberegister)
              matrix_screen_pixel(out);
            }
            row >>=1; // Das n&auml;chste Bit wird &uuml;berpr&uuml;ft
          }
    }
  }
}


void matrix_screen_pixel(uint32_t input) {
  uint8_t i = 0;
 
    for(i = 0; i < 32; i++) {
        if((i < 26 && i > 16) || (i < 10)) {
          if(input & 0x80000000) shift_low();
          else shift_high();
        }
        else {
          if(input & 0x80000000) shift_high();
          else shift_low();
        }
        input <<= 1;
    }
    clock_output();

  PORTB &= ~(1 << DS);
  PORTB &= ~(1 << SCK);
  PORTB &= ~(1 << OCK);
  
}


void adc_init() {
    uint16_t trash;
    ADMUX =  (1 << MUX0); //PB2
    DIDR0 |= (1<<ADC0D); //PB2  (ADC0)
    ADCSRA = (1 << ADPS1) | (1 << ADPS0) | (1 << ADEN); //Division 8
    get_adcval(&trash); //First Conversion
}


void adc_start() { 
    ADCSRA |= (1 << ADSC);
}


void get_adcval(uint16_t *val) {
  adc_start();
  while(ADCSRA & (1 << ADSC));
  *val = ADCW;
}


uint8_t getkey() {
  uint8_t key = 0;
  uint16_t adc_wert = 0;
  uint16_t zaehl = 0;  
  while(1) { 
        get_adcval(&adc_wert);
        zaehl++;
        if(adc_wert <= 50) { //Taste 4 von links
            key = 4;
            break;
        }
        else if(adc_wert <= 280 ) { //Taste 3 von links
            key = 3;
            break;
        }
        else if(adc_wert <= 540) { //Taste 2 von links
            key = 2;
            break;
        }// bis hier
        else if (adc_wert <= 790){ //Taste 1 von links
            key = 1;
            break;
        }  
        
        else if(adc_wert <= 1024) { //keine Taste
            key = 0;   
        }
        if(zaehl >= 10) break;
 }
 rand_timer += zaehl+key;
 return key;
}


void timer_init() {
  TIMSK |= (1 << TOIE0);
  TCCR0B |= (1 << CS01); //Prescaler 8
  TCNT0 = 0x0;  //Startwert 1
}


ISR(TIMER0_OVF_vect) { //Bildschirmausgabe
  ball_timer++;
  if(ball_timer % 2 && !(game_running)) return; //Bei der m&ouml;glichen Textausgabe darf nur jedes zweite Mal der Interrupt vollst&auml;ndig ablaufen
  if(game_running) output_game();
  matrix_output();
  if((ball_timer % 10) == 0) rand_timer++;
  if(ball_timer >= 100  && game_running) {
    ball_timer = 0;
    next_r_ball();
  }
}


void clear_screen() {
  uint8_t i = 0;
  for(i = 0; i < 5; i++) {
    screen_buffer_second[i]= 0x0; 
    screen_buffer_first[i] = 0x0;
  }
}


void start_game() {
  uint8_t i = 0;
  game_failed_var = 0x0;
  for(i = 0; i < 5; i++) {
    cursor_a[i] = 0x0;
    cursor_b[i] = 0x0;
  }
  cursor_a[1] = 0x1;
  cursor_a[2] = 0x1;
  cursor_b[2] = 0x40;
  cursor_b[3] = 0x40;
  for(i = 0; i < 5; i++) ball[i]= 0x0;
  ball[2]= 0x4;
  ball_dir = 0;
  game_running = 1;
  output_game(); 
}


void output_game() {
  uint8_t i = 0;
  clear_screen();
  for(i = 0; i < 5; i++) screen_buffer_second[i] |= cursor_a[i] | cursor_b[i] | ball[i];
}


void cursor_a_down() {
 uint8_t i = 0;
 if(cursor_a[0]== 0x01) return;
 else {
  for(i = 0; i < 4; i++) cursor_a[i]= cursor_a[i+1];
  cursor_a[4] = 0x0;
 }
}


void cursor_a_up() {
 uint8_t i = 0;
 if(cursor_a[4]== 0x01) return;
 else {
  for(i = 4; i > 0; i--) cursor_a[i]= cursor_a[i-1];
  cursor_a[0]= 0x0;
 }
}


void cursor_b_down() {
 uint8_t i = 0;
 if(cursor_b[0] == 0x40) return;
 else {
  for(i = 0; i < 4; i++) cursor_b[i]= cursor_b[i+1];
  cursor_b[4] = 0x0;
 }
}


void cursor_b_up() {
 uint8_t i = 0;
 if(cursor_b[4] == 0x40) return;
 else {
  for(i = 4; i > 0; i--) cursor_b[i] = cursor_b[i-1];
  cursor_b[0] = 0x0;
 }
}


void next_r_ball() {
  uint8_t col = 5;
  uint8_t i = 0;
  
  i = check_ball_coll();
  
  if(i != 0) {  
      if(i % 2) {  //Rechte Seite aufgeschlagen
        i = rand() % 4;
        if(i == 1) i = 0;
      } 
      else {    //Linke Seite aufgeschlagen
        i = rand() % 4;
        if(i == 0 || i == 1) i = 1;
        else i += 2;
      }
        ball_dir = i;
  }
  
  for(i = 0; i < 5; i++) if(ball[i] != 0) col = i; 

  
  switch(ball_dir) {
    
    case 0x0: //links
      ball[col] <<= 1;
      break;
    case 0x1: //rechts
      ball[col] >>= 1;
      break;
    case 0x2: //links-hoch

      if(col == 4) { ball_dir = 3; break; }
      ball[col+1] = ball[col] << 1;
      ball[col] = 0x0;
      col++;
      break;
    case 0x3: //links-runter
      if(col == 0) { ball_dir = 2; break; }
      ball[col-1] = ball[col] << 1;
      ball[col] = 0x0;
      col--;
      break;
    case 0x4: //rechts-hoch
      if(col == 4) { ball_dir = 5; break; }
      ball[col+1] = ball[col] >> 1;
      ball[col] = 0x0;
      col++;
      break;
    case 0x5: //rechts-runter
      if(col == 0) { ball_dir = 4; break; }
      ball[col-1] = ball[col] >> 1;
      ball[col] = 0x0;
      col--;
      break;
    default:
      break;
      
  }
    if(ball[col] == 0x0 && game_failed_var == 0) game_failed_var = 0x2;   //Bei A-Spieler raus
    if(ball[col] >= 0x80 && game_failed_var == 0) game_failed_var = 0x1;  //Bei B-Spieler raus

  return;
    
}



uint8_t check_ball_coll() {
  uint8_t temp_coll[5] = {0x0,0x0,0x0,0x0,0x0};
  uint8_t col = 0;
  uint8_t i = 0;
  uint8_t col_point = 0;
  
  for(i = 0; i < 5; i++) { 
    temp_coll[i] |= cursor_a[i] | cursor_b[i]; 
    if(ball[i] != 0) col = i; 
  }
  
  if( (temp_coll[col] << 1 ) & ball[col] && col == 2) col_point = 1;//Rechte Seite
  if( (temp_coll[col] >> 1 ) & ball[col] && col == 2) col_point = 2;//Linke Seite
  if( (temp_coll[col] << 1 ) & ball[col] && col < 2) col_point = 3; //Rechte Seite
  if( (temp_coll[col] >> 1 ) & ball[col] && col > 2) col_point = 4; //Linke Seite
  if( (temp_coll[col] << 1 ) & ball[col] && col < 2) col_point = 5; //Rechte Seite
  if( (temp_coll[col] >> 1 ) & ball[col] && col > 2) col_point = 6; //Linke Seite
  
  return col_point;
}



void game_failed() {
  uint8_t temp_show[5] = {0,0,0,0,0};
  uint8_t i = 0;
  
  game_running = 0;
  clear_screen();
  
  for(i = 0; i < 5; i++) temp_show[i] = pgm_read_byte(&unfriendly_sm[i]);
  output(temp_show,2);
  _delay_ms(100);
  clear_screen();
  
  switch(game_failed_var) {
    case 0x1: points_a++; break; //A hat ein Punkt gemacht
    case 0x2: points_b++; break; //B hat ein Punkt gemacht
    default: break; 
  }

  for(i = 0; i < 5; i++) temp_show[i] = pgm_read_byte(&ansi[game_failed_var % 2][i]);

  output(temp_show,2);
  _delay_ms(100);
  
  clear_screen();
  for(i = 0; i < 5; i++) temp_show[i] = pgm_read_byte(&ansi[26+points_a][i]);
  for(i = 0; i < 5; i++) temp_show[i] |= pgm_read_byte(&ansi[36][i]);
  output(temp_show,1);
  for(i = 0; i < 5; i++) temp_show[i] = pgm_read_byte(&ansi[26+points_b][i]);
  output(temp_show,2);
  
   _delay_ms(150);
   
   if(points_a == 9) {
    clear_screen();
    output_text("A WIN",SCROLLING);
    points_a = points_b = 0;
   }
   if(points_b == 9) {
    clear_screen();
    output_text("B WIN",SCROLLING);
    points_a = points_b = 0;
   }
   
   start_game();

}


uint32_t rand() {
 return  (ball_timer - rand_timer);
}


void output_text(char* text,uint8_t func) { //Optimierung
  uint8_t letter = 0,i,k,j = 0;
  uint8_t temp_buff_1[5] = {0,0,0,0,0};
  uint8_t temp_buff_2[5] = {0,0,0,0,0}; //Jedes Byte bildet eine Zeile, die Bits die Spalten
  volatile uint8_t text_buffer[6][5] = {0};

  
   while(*text) { //Text vom Flash in RAM puffern
     if(*text == 32) *text = 65+37;
     for(i = 0; i < 5; i++) text_buffer[letter][i] = pgm_read_byte(&ansi[(*text)-65][i]);
     letter++;
     text++;
     if(letter > 5) break;
   }
    
  if(func == SCROLLING) {
    for(j = 0; j < (14 +(4*letter)); j++) { //Zwei Matrizen mit a 7 Spalten + die Anzahl der Pixel der Zeichen die au&szlig;erhalb des Bildschirms starten
      for(i = 0; i < 5; i++) { //Jede Zeile wird berechnet, es gibt 5 Zeilen und 7 Spalten
        for(k = 0; k < letter; k++) { //Jeder Pixel jedes Zeichens kommt in direkt zusammen in eine Zeile
          if(j+1 > k*5) temp_buff_1[i] |= text_buffer[k][i] << 5 >> j-(k*5); //Rechts-Shift f&uuml;r 4 Pixel Zeichenabstand, Links-Shift zum scrollen
          if(j > (k*5)+7) temp_buff_2[i] |= text_buffer[k][i] << 5 >> j-(k*5)-7; //Sobald j < 7, Ausgabe auch auf andere Matrix erweitern
        }
      }
      output(temp_buff_1,2); //Ausgabe
      output(temp_buff_2,1);
      for(i = 0; i < 5; i++) { //F&uuml;r den n&auml;chsten Scroll-Schritt, Puffer leeren
        temp_buff_1[i] = 0x0;
        temp_buff_2[i] = 0x0;
      } 
    }
  }
  
  if(func == STATIC) { //Baustelle
     for(i = 0; i < 5; i++) {
        for(k = 0; k < letter; k++) {
          temp_buff_1[i] |= text_buffer[k][i] << 5+(4*k) >> 14;
          temp_buff_2[i] |= text_buffer[k][i] << 5+(4*k) >> 14-7;
        }
      }
      output(temp_buff_1,2);
      output(temp_buff_2,1);    

  }
}