Робот для игры в крестики-нолики

Видеоурок: Видеоурок SingTown OpenMV — робот-манипулятор для игры в крестики-нолики, конкурс электроники 2024

Робот для игры в крестики-нолики работает в три этапа: 1. Распознавание изображения — получение массива фигур на доске. 2. Алгоритм стратегии игры. 3. Управление механической рукой для захвата и установки фигур.

В качестве аппаратной платформы мы использовали OpenMV4 H7 от SingTown, и весь код выполняется прямо на OpenMV! Это включает управление механической рукой, управление реле, алгоритм стратегии игры и алгоритм распознавания изображения.

Механическая рука полностью напечатана на 3D-принтере, использует 3 сервопривода и управляется напрямую через плату расширения сервоприводов OpenMV.

Захват фигур реализован с помощью электромагнита, поскольку в качестве фигур я взял 10 плоских батареек-таблеток. OpenMV управляет электромагнитом через реле.

1. Распознавание изображения очень простое: сначала получаем изображение в оттенках серого, затем в 9 областях доски получаем информацию о цвете — в OpenMV это делается с помощью get_statistics(). По значению яркости определяется, стоит ли там чёрная фигура, белая фигура или клетка пуста.
2. Для вычисления следующего хода мой хороший друг и учитель ChatGPT посоветовал использовать алгоритм minimax и написал за меня этот код.
3. Управление механической рукой тоже довольно простое: для зоны ожидания захвата фигуры и для каждой из 9 клеток доски заранее определяется положение руки. Обычно это делается с помощью функции обучения (teach-in), но поскольку моя рука была сделана всего за один день в большой спешке, положения я подбирал прямо по коду.

# robot.py

import time
from servo import Servos
from machine import SoftI2C, Pin
import math

# Управление реле, реле управляет электромагнитом
pin1 = Pin('P1', Pin.OUT_PP, Pin.PULL_NONE)
pin1.value(0)

# Плата расширения сервоприводов PCA9685
i2c = SoftI2C(sda=Pin('P5'), scl=Pin('P4'))
servo = Servos(i2c, address=0x40, freq=50, min_us=650, max_us=2800, degrees=180)

# Исходное положение трёх сервоприводов
servo.position(0, 0)
servo.position(1, 90)
servo.position(2, 90)

# Глобальная переменная для плавного перемещения
servo_positions = [0,90,90]


# Управление перемещением одного сервопривода
def move(index, angle):
    servo.position(index, angle)
    servo_positions[index] = angle


# Управление перемещением трёх сервоприводов
def move_list(angle_list):
    print(angle_list)
    move(0, int(angle_list[0]))
    move(1, int(angle_list[1]))
    move(2, int(angle_list[2]))


# Плавное перемещение трёх сервоприводов
def slow_move_to(angle_list):

    init_positions = servo_positions.copy()

    d0 = angle_list[0] - init_positions[0]
    d1 = angle_list[1] - init_positions[1]
    d2 = angle_list[2] - init_positions[2]

    dm = int(max(abs(d0), abs(d1), abs(d2)))
    if dm == 0:
        return

    for i in range(dm+1):
        move_list([init_positions[0]+i*d0/dm,
        init_positions[1]+i*d1/dm,
        init_positions[2]+i*d2/dm])

        time.sleep_ms(40)


# Положения зоны захвата фигур
PICK = [[74,128,19], [82,128,17], [90,125,14], [98,128,17], [106,128,19]]
# Приподнятое положение руки над зоной захвата
HIGH_PICK = [90,95,55]

# Положения установки фигур на доске
BOARD = [
    [[82,150,55], [82,140,40], [81,133,30]],
    [[90,150,55], [90,140,40], [90,133,30]],
    [[98,150,55], [98,140,40], [99,133,30]]
]

# Положение над доской перед установкой фигуры
HIGH_BOARD = [90,120,70]


# Захват фигуры и установка её в позицию x, y
def pick_and_place(x,y):

    slow_move_to(HIGH_PICK)
    time.sleep_ms(500)

    slow_move_to(PICK[2])
    time.sleep_ms(500)

    slow_move_to(HIGH_PICK)
    time.sleep_ms(500)

    slow_move_to(HIGH_BOARD)
    time.sleep_ms(500)

    slow_move_to(BOARD[y][x])
    time.sleep_ms(500)
    pin1.value(1) # реле включено
    time.sleep_ms(500)

    slow_move_to(HIGH_PICK)
    pin1.value(0) # реле выключено
    time.sleep_ms(500)

    slow_move_to([0,90,90])


if __name__ == "__main__":
# Для калибровочного теста

    time.sleep_ms(1)

    for order in [
        BOARD[1][1], BOARD[0][0], BOARD[1][0],
        BOARD[2][0], BOARD[2][1], BOARD[2][2],
        BOARD[1][2], BOARD[0][2], BOARD[0][1],
    ]:
        slow_move_to(HIGH_BOARD)
        time.sleep_ms(500)
        slow_move_to(order)
        time.sleep_ms(500)

    #slow_move_to(BOARD[0][2])


    #for x in PICK:
        #slow_move_to(HIGH_PICK)
        #time.sleep_ms(500)
        #slow_move_to(x)
        #time.sleep_ms(500)

    slow_move_to([0,90,90])

# chess.py
SIZE = 3

# Проверка победы
def check_win(board, player):
    # Check rows and columns
    for i in range(SIZE):
        if all(board[i][j] == player for j in range(SIZE)) or \
           all(board[j][i] == player for j in range(SIZE)):
            return True
    # Check diagonals
    if all(board[i][i] == player for i in range(SIZE)) or \
       all(board[i][SIZE - 1 - i] == player for i in range(SIZE)):
        return True
    return False

# Проверка на ничью
def check_draw(board):
    return all(board[i][j] != ' ' for i in range(SIZE) for j in range(SIZE))


# Вычисление оценки стратегии
def minimax(board, depth, is_maximizing):
    computer = 'X'
    player = 'O'

    if check_win(board, computer):
        return 10 - depth
    if check_win(board, player):
        return depth - 10
    if check_draw(board):
        return 0

    if is_maximizing:
        best_score = float('-inf')
        for i in range(SIZE):
            for j in range(SIZE):
                if board[i][j] == ' ':
                    board[i][j] = computer
                    score = minimax(board, depth + 1, False)
                    board[i][j] = ' '
                    best_score = max(score, best_score)
        return best_score
    else:
        best_score = float('inf')
        for i in range(SIZE):
            for j in range(SIZE):
                if board[i][j] == ' ':
                    board[i][j] = player
                    score = minimax(board, depth + 1, True)
                    board[i][j] = ' '
                    best_score = min(score, best_score)
        return best_score


# Вычисление позиции следующего хода
def computer_move(board):
    if board == [
        [" "," "," "],
        [" "," "," "],
        [" "," "," "]
    ]:
        return 1,1
    best_score = float('-inf')
    move = (-1, -1)
    for i in range(SIZE):
        for j in range(SIZE):
            if board[i][j] == ' ':
                board[i][j] = 'X'
                score = minimax(board, 0, False)
                board[i][j] = ' '
                if score > best_score:
                    best_score = score
                    move = (i, j)
    if move != (-1, -1):
        # board[move[0]][move[1]] = 'X'
        print(f"Computer places X at ({move[0]}, {move[1]})")
        return move[0], move[1]


# Проверка, чей ход
def check_turn(board):
    x_count = sum(row.count("X") for row in board)
    o_count = sum(row.count("O") for row in board)
    return "X" if x_count == o_count else "O"

# main.py
import csi, image, time
csi0 = csi.CSI()

from pyb import Pin
import robot
import chess

csi0.reset()
csi0.pixformat(csi.GRAYSCALE)
csi0.framesize(csi.QVGA)
csi0.snapshot(time = 2000)

clock = time.clock()


# Кнопка (тактовая)
pin0 = Pin('P0', Pin.IN, Pin.PULL_UP)


distance = 43
block = 10


# Генерация положений областей сетки 3x3
def generate_centered_rois(width, height, b, k):
    rois = []

    # Вычисление смещения центра каждой ROI
    offset = (b - k) // 2

    # Вычисление ширины и высоты всей матрицы 3x3
    total_width = 3 * b
    total_height = 3 * b

    # Вычисление начальной точки в левом верхнем углу для центрирования матрицы
    start_x = (width - total_width) // 2
    start_y = (height - total_height) // 2

    for i in range(3):
        row = []
        for j in range(3):
            x_center = start_x + j * b + b // 2
            y_center = start_y + i * b + b // 2
            x = x_center - k // 2
            y = y_center - k // 2
            row.append((x, y, k, k))
        rois.append(row)

    return rois


# Положения областей сетки 3x3
rois = generate_centered_rois(csi0.width(), csi0.height(), distance, block)


# Массив доски
# Чёрная фигура: X
# Белая фигура: O
# Нет фигуры: пустая строка
board = [
     [" "," "," "],
     [" "," "," "],
     [" "," "," "],
]


# Ожидание нажатия и отпускания кнопки
def wait_key():
    while pin0.value():
        img = csi0.snapshot().lens_corr(1.8)
        for y in range(len(rois)):
            for x in range(len(rois[y])):
                img.draw_rectangle(rois[y][x])
    while not pin0.value():
        time.sleep_ms(1)


while(True):
    clock.tick()
    wait_key()
    img = csi0.snapshot().lens_corr(1.8)


    # Распознавание изображения для получения массива доски
    for y in range(len(rois)):
        for x in range(len(rois[y])):
            gray = img.get_statistics(roi=rois[y][x]).mean
            if gray < 100:
                board[y][x] = "X"
            elif gray > 200:
                board[y][x] = "O"
            else:
                board[y][x] = " "


    # Вывод текущего массива доски
    for line in board:
        print(line)
    print()


    # Отрисовка массива доски
    for y in range(len(rois)):
        for x in range(len(rois[y])):
            if board[y][x] == "X":
                color = 255
            elif board[y][x] == "O":
                color = 0
            elif board[y][x] == " ":
                color = 127
            img.draw_rectangle(rois[y][x], color=color)


    # Стратегия игры
    if chess.check_win(board, 'O'):
        print("你赢啦!")

    elif chess.check_win(board, 'X'):
        print("我赢啦！")
    elif chess.check_draw(board):
        print("平局啦！")
    elif chess.check_turn(board) == "X":
        # Вычисление, куда поставить следующую фигуру
        line,row = chess.computer_move(board)
        # Отрисовка крестика в целевой клетке доски
        img.draw_cross((int(rois[line][row][0]+block/2), int(rois[line][row][1]+block/2)), size=block, color=0)
        csi0.flush()
        # Робот берёт и устанавливает фигуру
        robot.pick_and_place(row, line)
        csi0.flush()
    elif chess.check_turn(board) == "O":
        print("该你下了！")