Читать онлайн «Встраиваемые системы. Проектирование приложений на микроконтроллерах семейства 68HC12/HCS12 с применением языка С». Страница 119

 LCD_output("in the order ");

 LCD_output("seen below. The ");

 LCD_output("star shows the ");

 LCD_output("current piece ");

 LCD_output("selected. You ");

 LCD_output("can choose a ");

 LCD_output("different piece ");

 LCD_output(" by using the ");

 LCD_output(" arrow buttons ");

 newline();

 pause();

 LCD_output("and select the ");

 LCD_output("piece you want ");

 LCD_output("to move by ");

 LCD_output("pressing the X ");

 // кнопка "Выбор"

 LCD_output("button. Choose ");

 LCD_output("the direction to ");

 LCD_output("move that piece ");

 LCD_output("with the arrows. ");

 new_line();

 LCD_output("WINDING ");

 LCD_output("CONFIGURATION: ");

 newline();

}

//*****************************************************************

// display_win: ВЫВОД СООБЩЕНИЯ О ПОБЕДЕ

//*****************************************************************

void display_win() {

 LCD_output(" YOU WIN!!! ");

 LCD_output("CONGRATULATIONS ");

}

//********************************************************************

// get_move: ДВИЖЕНИЕ ФИШКИ: задается позиция фишки, выбранной игро-

// ком и направление ее движения

//********************************************************************

void get_move(int* direction, int *row, int *col, int* select) {

 int n = 0;

 int button = 0;

 unsigned char temp = ZERO;

 newline();

 LCD_output("Choose move or ");

 LCD_output("select piece: ");

 while (button == 0) {

  // цикл выполняется, пока нажата кнопка

  temp = PORTS;

  temp = temp & 0x7С

  switch (temp) //какая кнопка нажата?

  {

  case L_BUTTON:

   button = LEFT;

   break;

  case R_BUTTON:

   button = RIGHT;

   break;

  case U_BUTTON:

   button = UP;

   break;

  case D_BUTTON:

   button = DOWN;

   break;

  case S_BUTTON:

   button = SELECT;

   break;

  } // конец цикла switch

 }//конец цикла while

 n = 0;

 switch (button) //реакция на нажатие кнопки

 {

 case UP:

  if (*row > 1) *row -= 1;

  else display_error(UP);

  break;

 case DOWN:

  if (*row < SIZE) *row += 1;

  else display_error(DOWN);

  break;

 case LEFT:

  if (*col > 1) *col -= 1;

  else display_error(LEFT);

  break;

 case RIGHT:

  if (*col < SIZE) *col += 1

  else display_error(RIGHT);

  break;

 case SELECT:

  *select = 1;

  LCD_output("Pick a direction");

  *direction = 0;

  while (*direction == 0) {

   temp = PORTS;

   temp = temp & 0x7C;

   switch (temp) {

   case L_BUTTON:

    *direction = LEFT;

    break;

   case R_BUTTON:

    *direction = RIGHT;

    break;

   case U_BUTTON:

    *direction = UP;

    break;

   case D_BUTTON:

    *direction = DOWN;

    break;

   }

  }

  break;

 }

}

//********************************************************************

// randomize_board: ВЫБОР СЛУЧАЙНОГО ИСХОДНОГО СОСТОЯНИЯ ФИШЕК

//********************************************************************

void randomize_board(int board_array[]) {

 int temp = 0;

 int i;

 unsigned char temp2 = 0x00;

 for (i=0; i<ARRAY_MAX+1; i++) {

  temp2 = TCNTL;

  temp = mod(temp2,15); //случайное значение using the TCNT counter

  swap2(i,temp, board_array);

 }

}

//********************************************************************

// MOD: МАТЕМАТИЧЕСКАЯ ФУНКЦИЯ

//********************************************************************

unsigned char mod(unsigned char num, int modulus) {

 while ((num - modulus) > 0) num = num - modulus;

 return num;

}

//********************************************************************

// display_board2: Выводит табло, как одну колонку значений

//********************************************************************

void display_board2(int board_array[ARRAY_MAX+1]) {

 int = 0;

 int n;

 for (i=0; i<ARRAY_MAX+1; i++) {

  n = board_array[i];

  int2char(n);

 }

 LCD_output("\n");

}

//********************************************************************

// display_board: Выводит табло как массив 4×4

//********************************************************************

void display_board(int A[SIZE][SIZE], int row, int col, int direction) {

#pragma abs_address 0x0800

 int i;

 int j;

 int num;

#pragma end_abs_address

 newline();

 LCD_output("| Column ");

 LCD_output("| 1 2 3 4 ");

 LCD_output("-------------------");

 for (i=0; i < SIZE; i++) {

  j=0;

  switch(i) {

  case 0:

   LCD_output("R 1 |");

   break;

  case 1:

   LCD_output("o 2 |");

   break;

  case 2:

   LCD_output("w 3 |");

   break;

  case 3:

   LCD_output(" 4 |");

   break;

  }

  for (j=0; j < SIZE; j++) {

   num = A[i][j];

   if (num == 0) LCD_output(" ");

   else int2char(num);

   if ((i+1 == row) && (j+1) == col))

    LCD_output("*");

   else LCD_output(" ");

  }

 }

 newline();

 LCD_output("You are at (R,C)");

 LCD_output(" (");

 int2char(row);

 LCD_output(",");

 int2char(col);

 LCD_output(") =");

 int2char(A[row-1];

 LCD_output(" ");

 newline();

}

//********************************************************************

// INT2CHAR: задается как integer и выводится на ЖКД в виде

// двух символов

//********************************************************************

void int2char(int i) {

 if (i > 9) {

  LCD_output("I");

  i -= 10;

 } else {

  LCD_output('; ");

 }

 switch(i) {

 case 0:

  LCD_output("0");

  break;

 case 1:

  LCD_output("1");

  break;

 case 2:

  LCD_output("2");

  break;

 case 3:

  LCD_output("3");

  break;

 case 4:

  LCD_output("4");

  break;

 case 5:

  LCD_output("5");

  break;

 case 6:

  LCD_output("6");

  break;

 case 7:

  LCD_output("7");

  break;

 case 8:

  LCD_output("8");

  break;

 case 9:

  LCD_output("9");

  break;

 }

}

//********************************************************************

//Check_Win: Эта функция проверяет соответствие текущего положения ситуации

// победы при победе win - 1, в остальных случаях - 0

//********************************************************************

int check_win(int array[ARRAY_MAX+1]) {

 int i;

 int win = 1;

 for (i=0; i<ARRAY_MAX+1; i++) {

  if (array[i] != win_array[i]) win = 0;

 }

 return win;

}

//********************************************************************

//Convert_multi_single: Эта функция преобразует двухмерный массив

//в одномерный

//********************************************************************

int convert_multi_single(int A[SIZE][SIZE], int В[ARRAY_MAX+1]) {

 int n = 0;

 int i = 0;

 int j = 0;

 for (i=0; i<SIZE; i++) {

  for (j=0; j<SIZE; j++) {

   B[n] = A[i][j] ;

   n++;

  }

 }

}

//****************************************************************

//Convert_single_multi: Эта функция преобразует одномерный массив

//в двухмерный

//****************************************************************

void convert_single_multitint A[ARRAY_MAX+1], int В[SIZE][SIZE]) {

 B[0][0] = A[0];

 B[0][1] = A[1];

 B[0][2] = A[2];

 B[0][3] = A[3];

 B[1][0] = A[4];

 B[1][1] = A[5];

 B[1][2] = A[6];

 B[1][3] = A[7];

 B[2][0] = A[8];

 B[2][1] = A[9];

 B[2][2] = A[10];

 B[2][3] = A[11];

 B[3][0] = A[13];

 B[3][2] = A[14];

 B[3][3] = A[15];

}

//********************************************************************

// Try_move: Эта функция позволяет игроку определить некорректность

// своего хода. Если он корректен, то движение выполняется,

// если же некорректен, то выводится соответствующее сообщение

//********************************************************************

void try_move(int move, int row, int col, int array[SIZE][SIZE]) {

 switch(move) {