ВИЗУАЛИЗАТОР МАТРИЧНЫХ ОПЕРАЦИЙ 🎲

Две матрицы 8x8 (Matrix A и Matrix B)
Операции: AND, OR, XOR, NOT, сдвиги, повороты
LED матрица отображает результат операции
Потенциометры: выбор операции и управление матрицами
Кнопки: смена режимов, сохранение паттернов

Для MAX7219:
  VCC → 5V
  GND → GND
  DIN → pin 11
  CS → pin 10  
  CLK → pin 13

Или прямое подключение (для 64 светодиодов):
  Строки 0-7 → пины 2-9
  Столбцы 0-7 → пины 10-17 через транзисторы

// ОПРЕДЕЛЕНИЯ:
матрица_A[8][8], матрица_B[8][8], результат[8][8]
операция = AND (изначально)

// ОСНОВНОЙ ЦИКЛ:
считываем_потенциометры() // выбор операции и данных

если (кнопка_смены_режима):
  переключаемся_между_матрицами() // редактируем A или B

если (кнопка_редактирования):
  изменяем_текущую_матрицу() // добавляем/удаляем точки

выполняем_операцию(матрица_A, матрица_B, операция, результат)

отображаем_результат_на_LED(результат)

отображаем_информацию_на_LCD(операция, текущая_матрица)

#define MATRIX_SIZE 8

byte matrixA[MATRIX_SIZE][MATRIX_SIZE];
byte matrixB[MATRIX_SIZE][MATRIX_SIZE]; 
byte result[MATRIX_SIZE][MATRIX_SIZE];

enum Operation { OP_AND, OP_OR, OP_XOR, OP_NOT, OP_SHIFT_LEFT, OP_SHIFT_RIGHT, OP_ROTATE };
Operation currentOperation = OP_AND;

// Инициализация начальных паттернов
void initializeMatrices() {
  // Матрица A - шахматный паттерн
  for (int i = 0; i < MATRIX_SIZE; i++) {
    for (int j = 0; j < MATRIX_SIZE; j++) {
      matrixA[i][j] = (i + j) % 2;
    }
  }
  
  // Матрица B - рамка
  for (int i = 0; i < MATRIX_SIZE; i++) {
    for (int j = 0; j < MATRIX_SIZE; j++) {
      matrixB[i][j] = (i == 0 || i == MATRIX_SIZE-1 || j == 0 || j == MATRIX_SIZE-1) ? 1 : 0;
    }
  }
}

void performOperation() {
  for (int i = 0; i < MATRIX_SIZE; i++) {
    for (int j = 0; j < MATRIX_SIZE; j++) {
      switch(currentOperation) {
        case OP_AND:
          result[i][j] = matrixA[i][j] && matrixB[i][j];
          break;
        case OP_OR:
          result[i][j] = matrixA[i][j] || matrixB[i][j];
          break;
        case OP_XOR:
          result[i][j] = matrixA[i][j] ^ matrixB[i][j];
          break;
        case OP_NOT:
          result[i][j] = !matrixA[i][j];
          break;
        case OP_SHIFT_LEFT:
          result[i][j] = (j < MATRIX_SIZE-1) ? matrixA[i][j+1] : 0;
          break;
        case OP_SHIFT_RIGHT:
          result[i][j] = (j > 0) ? matrixA[i][j-1] : 0;
          break;
      }
    }
  }
}

void updateOperationFromPot() {
  int potValue = analogRead(OP_POT_PIN);
  int opIndex = map(potValue, 0, 1023, 0, 6);
  currentOperation = (Operation)opIndex;
}

void handleEditMode() {
  int xPot = analogRead(X_POT_PIN);
  int yPot = analogRead(Y_POT_PIN);
  
  int x = map(xPot, 0, 1023, 0, MATRIX_SIZE-1);
  int y = map(yPot, 0, 1023, 0, MATRIX_SIZE-1);
  
  if (digitalRead(EDIT_BUTTON_PIN) == LOW) {
    // Переключаем пиксель в текущей матрице
    if (currentEditMatrix == MATRIX_A) {
      matrixA[y][x] = !matrixA[y][x];
    } else {
      matrixB[y][x] = !matrixB[y][x];
    }
    delay(200); // антидребезг
  }
}

void displayMatrix(byte matrix[MATRIX_SIZE][MATRIX_SIZE]) {
  for (int row = 0; row < MATRIX_SIZE; row++) {
    for (int col = 0; col < MATRIX_SIZE; col++) {
      // Для MAX7219
      lc.setLed(0, row, col, matrix[row][col]);
      
      // Или для прямого управления:
      // digitalWrite(rowPins[row], matrix[row][col] ? HIGH : LOW);
    }
  }
}

void animateOperation() {
  // Показываем промежуточные шаги операции
  for (int step = 0; step <= MATRIX_SIZE; step++) {
    for (int i = 0; i < MATRIX_SIZE; i++) {
      for (int j = 0; j < MATRIX_SIZE; j++) {
        if (j <= step) {
          // Применяем операцию к уже обработанным столбцам
          result[i][j] = matrixA[i][j] && matrixB[i][j];
        } else {
          // Показываем исходные данные для необработанных
          result[i][j] = matrixA[i][j];
        }
      }
    }
    displayMatrix(result);
    delay(100);
  }
}

const byte PATTERNS[][8][8] = {
  { // Шахматная доска
    {1,0,1,0,1,0,1,0},
    {0,1,0,1,0,1,0,1},
    // ...
  },
  { // Сердце
    {0,1,1,0,0,1,1,0},
    {1,1,1,1,1,1,1,1},
    // ...
  },
  // ... другие паттерны
};

void loadPattern(int patternIndex, byte targetMatrix[8][8]) {
  for (int i = 0; i < 8; i++) {
    for (int j = 0; j < 8; j++) {
      targetMatrix[i][j] = PATTERNS[patternIndex][i][j];
    }
  }
}

void matrixMultiply() {
  // Умножение матриц (логическое)
  for (int i = 0; i < MATRIX_SIZE; i++) {
    for (int j = 0; j < MATRIX_SIZE; j++) {
      result[i][j] = 0;
      for (int k = 0; k < MATRIX_SIZE; k++) {
        result[i][j] |= matrixA[i][k] && matrixB[k][j];
      }
    }
  }
}

void convolutionFilter(byte kernel[3][3]) {
  // Применение сверточного фильтра
  for (int i = 1; i < MATRIX_SIZE-1; i++) {
    for (int j = 1; j < MATRIX_SIZE-1; j++) {
      int sum = 0;
      for (int ki = -1; ki <= 1; ki++) {
        for (int kj = -1; kj <= 1; kj++) {
          sum += matrixA[i+ki][j+kj] * kernel[ki+1][kj+1];
        }
      }
      result[i][j] = (sum >= 1) ? 1 : 0; // пороговая обработка
    }
  }
}

// Аналогично задачам на обработку изображений и паттернов:
"Реализовать алгоритм распознавания образов в двоичной матрице"

// Аналогично задачам на битовые операции из 9-11 классов:
"Применить битовые операции к каждому элементу матрицы"

// Аналогично задачам на алгоритмы обработки данных:
"Реализовать фильтрацию и преобразование матричных данных"

// ЭТАП 1: Статическое отображение матрицы
displayStaticPattern();

// ЭТАП 2: Базовые операции над двумя матрицами
performMatrixOperation(OP_AND);
displayResult();

// ЭТАП 3: Интерактивное редактирование матриц
handleMatrixEditing();
updateDisplay();

// ЭТАП 4: Сложные операции и анимации
performAdvancedOperations();
animateTransitions();

🎯 Двумерный массив 8x8:
   0 1 2 3 4 5 6 7  ← столбцы
0 [1,0,1,0,1,0,1,0]
1 [0,1,0,1,0,1,0,1] 
2 [1,0,1,0,1,0,1,0]
3 [0,1,0,1,0,1,0,1]
4 [1,0,1,0,1,0,1,0]
5 [0,1,0,1,0,1,0,1]
6 [1,0,1,0,1,0,1,0]
7 [0,1,0,1,0,1,0,1]
 ↑
строки

🔧 Операции:
AND: █ AND █ = █     OR: █ OR ░ = █     XOR: █ XOR █ = ░
     ░ AND █ = ░         ░ OR ░ = ░         █ XOR ░ = █