•

Published July 12, 2024 © GPL3+

Lora-Link Tournament Creator

YU-GI-OH LoraLink is a complete system for create and manage a YU-GI-OH tournament, allowing dueslist to register to tournament for conpetti

BeginnerWork in progress3 days71

Things used in this project

Hardware components

Raspberry Pi 3 Model B

AllThingsTalk LoRa Rapid Development Kit

Software apps and online services

Arduino IDE

The Things Industries The Things Stack

Story

Introduction

We are delighted to present YU-GI-OH LoraLink, an innovative project designed for YU-GI-OH duelist. YU-GI-OH LoraLink is a complete system for create and manage a YU-GI-OH tournament, allowing dueslist to register to tournament for conpetting. The project was carried out in 50 hours by Febvin Grégory and Gosse Théo, 3rd year students in computer science and networks at UniLaSalle Amiens.

https://www.unilasalle-amiens.fr/

WebSite for dueslist

The first part is an online platform designed specifically for YU-GI-OH players, offering a complete experience for participating in tournaments and managing decks.

To get started, duelists can register or log in to their personal account. This gives them access to all the features available on the platform.

A key feature is the creation of decks. On a dedicated page, duelists can easily create their decks. This includes

Another section allows duelists to manage their existing decks. They can consult the complete list of cards in their deck with images, making it easier to manage and organise before tournaments.

Finally, duelists can explore the tournaments available on a dedicated page. They can register for a tournament by selecting the deck they plan to use, ensuring optimum preparation and easier participation.

1 / 4

A management application for administrators

A Python application has been developed to enable tournament administrators to manage the entire tournament process efficiently. The main features of this application are as follows:

Tournament creation and management:

Administrators can create new tournaments and set the necessary parameters.
They can also create and organise tournament rounds.

Match Management:

The application allows users to check and manage information about each match in real time.
Administrators can define the winner of each match directly from the application.

Automatic Match Balancing:

The application uses an automatic system to create balanced matches based on players' scores.
This feature ensures fairer and more competitive matches throughout the tournament.

Tracking and Administration:

Administrators can track the progress of matches and rounds in progress.
All the information needed to manage the tournament is centralised and easily accessible via the application.

This application aims to simplify and automate the tasks of tournament administrators, making the process smoother, fairer and more efficient.

1 / 4

Dashboard

The dashboard, meanwhile, will serve as a simple display for all players to follow the current status of the tournament.

The first page of the dashboard will show the current list of tournaments in progress. Players will be able to easily select the tournament for which they want detailed information. This page will show the names of the tournaments, the dates, and possibly the organisers for quick and clear identification.

The second page of the dashboard will be dedicated to data from the current round of the selected tournament. It will provide precise information on each match in progress, such as the players competing, the current score, and the progress status of the match (for example, in progress, completed, or paused). This page will help players follow the progress of matches in real time and stay informed of results.

First page of the dashboard

Second page with more information

The Lora part of the project

To enable duelists to call a judge in the event of a dispute, we have installed a LoRa card equipped with several buttons. Each button corresponds to a specific type of problem that may arise during a match, such as a disputed point, a technical problem or a request for a break.

When a duellist presses a button, a message is immediately sent via The Things Network. This message contains all the information needed to identify the match.

A Python script has been developed to interact with The Things Network and retrieve these messages. This script processes the information received and stores it in a database.

The data stored in the database can then be accessed via the dashboard. The dashboard displays alerts in real time, allowing judges to see immediately which duelist has reported a problem and what type of problem it is. This allows the judges to intervene quickly and efficiently, ensuring that the tournament runs smoothly.

1 / 2

Conclusion

The YU-GI-OH LoraLink project represents a significant step forward in the management and monitoring of YU-GI-OH tournaments, using modern technologies such as LoRa and user-friendly web interfaces. By allowing duelists to easily register for tournaments, follow matches in real time via an intuitive dashboard, and quickly report disputes or technical problems, YU-Gi-OH LoraLink improves the overall experience for players and judges.

LoRa technology played a crucial role in this project. Thanks to its ability to transmit data over long distances with low power consumption, it enables reliable communication between duelists and judges, even in large environments such as large tournament halls. The system of buttons connected to the LoRa card ensures that any problems reported are quickly relayed to the judges via The Things Network, guaranteeing rapid and effective intervention.

The integration of LoRa into the tournament management system demonstrates not only technological innovation but also the ability to use cutting-edge solutions to solve practical problems. Processing data in real time and displaying it on the dashboard improves the transparency and fluidity of tournament operations.

We hope that YU-GI-OH LoraLink will provide tournament organisers with an effective and innovative solution, while offering an enriched and more user-friendly experience.

Custom parts and enclosures

Sketchfab still processing.

Code

Sodaq Explorer Code

#include <Sodaq_RN2483.h>

// Table definition
#define NUM_TABLE 54

// Serial definitions
#define DEBUG_SERIAL    SerialUSB
#define LORA_SERIAL     Serial2

// Pin definition
#define BUTTON_PIN      7

// LoRa configuration (OTAA)
const uint8_t APP_EUI[8] = {0x0A, 0x00, 0xAC, 0x0B, 0x20, 0x67, 0x00, 0xD0};
const uint8_t DEV_EUI[8] = {0x70, 0xB3, 0xD5, 0x7E, 0xD0, 0x06, 0x82, 0x59};
const uint8_t APP_KEY[16] = {0xBB, 0x53, 0x0E, 0xA1, 0xEA, 0x16, 0x34, 0x62, 0xF6, 0x99, 0x0D, 0x45, 0x27, 0xD4, 0x3D, 0xB4};

void setup() {
    // Initialize debug serial communication
    DEBUG_SERIAL.begin(57600);
    while (!DEBUG_SERIAL); // Wait for serial monitor to open

    // Initialize LoRa serial communication
    LORA_SERIAL.begin(LoRaBee.getDefaultBaudRate());

    // Initialize button pin
    pinMode(BUTTON_PIN, INPUT_PULLUP);

    // Initialize LoRa communication
    LoRaBee.setDiag(DEBUG_SERIAL);
    initializeLoRa();

    DEBUG_SERIAL.println("Setup complete. Waiting for button press to send payload.");
}

void loop() {
    if (digitalRead(BUTTON_PIN) == LOW) {
        delay(100); // Debounce delay
        sendPayload(); // Send table number as payload
        delay(1000); // Delay to avoid multiple sends on single button press
    }
}

void initializeLoRa() {
    delay(100);

    if (LoRaBee.initOTA(LORA_SERIAL, DEV_EUI, APP_EUI, APP_KEY, true)) {
        DEBUG_SERIAL.println("OTAA Keys Accepted.");
    } else {
        DEBUG_SERIAL.println("OTAA Key Setup Failed!");
        haltExecution();
    }
}

void sendPayload() {
    // Convert table number to bytes
    uint8_t payload[1];
    payload[0] = NUM_TABLE;

    DEBUG_SERIAL.print("Button pressed. Sending payload: ");
    DEBUG_SERIAL.println(NUM_TABLE); // Print the payload being sent

    // Send LoRa payload and handle response
    uint8_t attempts = 3; // Number of retry attempts
    bool success = false;

    while (attempts-- > 0 && !success) {
        switch (LoRaBee.send(1, payload, sizeof(payload))) {
            case NoError:
                DEBUG_SERIAL.println("Successful transmission.");
                success = true;
                break;
            case NoResponse:
                DEBUG_SERIAL.println("No response from the device.");
                break;
            case Timeout:
                DEBUG_SERIAL.println("Connection timed out. Check your serial connection.");
                break;
            case PayloadSizeError:
                DEBUG_SERIAL.println("Payload size error.");
                break;
            default:
                DEBUG_SERIAL.println("Unknown error.");
                break;
        }

        if (!success) {
            delay(1000); // Wait before retrying
        }
    }

    if (!success) {
        DEBUG_SERIAL.println("Failed to send payload after multiple attempts.");
    }
}

void haltExecution() {
    while (true) {}
}