Co'B Team:

•

•

•

Published June 23, 2023

Co'B : Connected Basket

Create a connected basketball hoop that utilizes sensors and technologies (MQTT, Flask, React) to collect, analyze, and visualize data

IntermediateWork in progress148

Things used in this project

Hardware components

Sodaq Explorer

The Sodaq Explorer is an Arduino-based development board specifically designed for Internet of Things (IoT) projects. It features a microcontroller, low-power wireless connectivity (such as LoRaWAN), and sensor interfaces. With the Sodaq Explorer, we can create custom IoT applications, collect data from sensors, communicate with other connected devices, and send data to the cloud for further analysis. It's a versatile platform for low-power IoT development.

M5Stack Color Sensor RGB TCS34725 Unit

IR Obstacle Avoidance

Software apps and online services

The Things Industries The Things Stack

To collect LoRa data

Arduino IDE

To program the board

Story

Introduction

Our project aims to design a connected basketball hoop that utilizes LoRa technology to collect and transmit real-time data from integrated sensors. The objective is to enable accurate performance tracking of players and provide an interactive experience during training sessions or games.

The connected basketball hoop is equipped with multiple sensors, including an infrared obstacle sensor to detect the presence of a ball and a color detector to identify the ball's color (red, green, or blue). These sensors provide essential information for evaluating shot accuracy and tracking individual player performances.

The data collected by the sensors is sent to a Flask server using the MQTT communication protocol. The server stores the data in a database for later analysis. The data is also processed in real-time and made available to a React web application.

The web application allows users to access match data based on players. Additionally, an animation is triggered whenever a shot is detected, adding a playful element to the experience.

We have also undertaken the design of a 3D enclosure to house the electronic components and ensure adequate protection. Furthermore, we are working on the development of a customized shield for the Sodaq Explorer board used as the hardware platform.

The project is currently in an advanced functional phase. We have successfully collected data from the sensors, transmitted it to the Flask server via MQTT, and visualized it in real-time in the React web application. We are continuing the development of the 3D enclosure and the customized shield to enhance integration and system robustness.

In summary, our connected basketball hoop offers accurate player performance tracking, real-time statistics visualization, and an interactive experience during training and games. It represents an innovative solution to enhance player skills and foster engagement and enthusiasm for basketball.

Technical details

Communication Module

The electronic system of the project utilizes the Sodaq Explorer board as the main hardware platform. The Sodaq Explorer is a development board based on the SAMD21 microcontroller and is compatible with the LoRaWAN network.

The Sodaq Explorer board is equipped with a LoRa module for long-range, low-power wireless communication. It also features USB connectivity, which makes programming and communication with other devices convenient.

In the project, the Sodaq Explorer board is used to collect data from the integrated sensors. These sensors include an infrared obstacle sensor and a color detector. The obstacle sensor is used to detect the presence of a ball in the basketball hoop, while the color detector is used to identify the color of the ball.

Once the sensor data is collected, it is transmitted to a Flask server using the MQTT communication protocol. The Flask server is hosted on a virtual machine or a Raspberry Pi and has a database to store the collected data.

Overall, the electronic system of the project relies on the Sodaq Explorer board to collect sensor data and transmit it to the Flask server. The web application then interacts with the Flask server to visualize and analyze the collected data. This enables the creation of a connected basketball hoop system that provides accurate information about player performance.

Sensors

1. RGB sensor

2. IR Obstacle avoidance sensor

Interface

The current interface of the web application allows you to visualize the score of two players in real time. You can see the individual scores of each player and track their progress throughout the match. When a shot is detected, the corresponding animation plays to add a playful element to the experience.

Additionally, the application is capable of identifying which player made the shot by analyzing the color of the ball. It determines the color (red, green, or blue) and associates it with the corresponding player. This allows you to track the individual performance of each player and know who scored with each shot.

Laptop view

However, it's important to note that the current interface primarily focuses on basic functionality, and there is room for further enhancements to expand the features and data visualization options. For example, you could consider displaying trend graphs, advanced statistics, or other relevant information to enrich the user experience.

Mobile view

The development of the interface can be continued by adding new features and improving the user experience to provide a more comprehensive view of player performance and enhanced interaction with the connected basketball hoop system.

Possible Extra Features

One possible improvement to the web application is to enhance the modeling of shots and their speed. Currently, the application detects shots based on the presence of the ball and plays the corresponding animation. However, you can further develop this functionality by incorporating additional sensors or algorithms to measure the speed of the shot. This would provide more detailed information about the shooting performance, such as the velocity of the ball and the shooting technique. The application could display the shot speed alongside the player's score, allowing users to analyze and compare their shooting performance over time.

To make the web application more engaging and interactive, you can introduce mini-games related to basketball. These mini-games could leverage the data collected from the connected basketball hoop, such as shot accuracy, speed, or timing. For example, you could create a shooting challenge where players have to hit targets within a certain time limit or compete in a virtual shooting contest against other players. These mini-games would provide an additional layer of entertainment and motivation for users to improve their skills and compete with others.

Another potential enhancement is to integrate blockchain technology into the application to authenticate and certify player matches. By leveraging the decentralized nature of blockchain, you can create a secure and transparent system for recording and verifying match results. Each shot made by a player could be timestamped and stored as a transaction on the blockchain, ensuring the integrity and immutability of the data. This would provide a reliable and tamper-proof record of player performances, which could be useful for competitions, rankings, or historical analysis. Additionally, incorporating blockchain-based authentication methods can enhance the security and trustworthiness of the overall system.

Conclusion

In conclusion, our connected basketball hoop project has successfully created an innovative and interactive experience by leveraging IoT and web technologies. Through real-time data collection, analysis of player performance, and triggered animations upon successful shots, our solution brings a new dimension to basketball training and matches. The identified areas for improvement, such as shot modeling, mini-games, and blockchain integration, offer exciting avenues for future development. Overall, our project showcases the potential of technology to transform sports experiences and engage players in new and captivating ways.

Acknowledgements

We would like to thank our teachers at UniLaSalle ESIEE Amiens and in particular Mr DAILLY and Mr Bracq who helped us a great deal in the realisation of our project, teaching us IOT as well as knowledge in the production and design of electronic cards.

Code

Flask API

Python

This code snippet sets up a MQTT message handler using the mqtt_client.on_message() decorator. When a message is received, it extracts the topic and payload from the message and decodes the payload using JSON. The decoded payload is then printed, and the message is added to a list called messages.

There is also a Flask route defined (/messages) that handles a GET request. It returns the messages list as a JSON response and clears the list. Additionally, it adds the necessary headers to enable cross-origin resource sharing (CORS). Lastly, it appends a default message of [0, 0, 0] to the messages list before sending the response.

@mqtt_client.on_message()
def handle_mqtt_message(client, userdata, message):
    data = dict(
        topic=message.topic,
        payload=message.payload.decode()
    )
    decoded_payload = json.loads(data['payload'])['uplink_message']['decoded_payload']
    print(f" message on topic: {data['topic']} with payload: {decoded_payload}")

    # Ajouter le message à la liste
    messages.clear()
    message_sent = decoded_payload['bytes']
    print(message_sent)
    messages.append(message_sent)


@app.route('/messages', methods=['GET'])
def get_messages():
    response = jsonify(messages)
    # Enable Access-Control-Allow-Origin
    response.headers.add("Access-Control-Allow-Origin", "*")

    messages.clear()

    messages.append([0, 0, 0])

    return response

while(digitalRead(TRIGGER_PIN) == HIGH) {
      delay(100);
    }

    tcs.setInterrupt(false); // turn LED
    delay(50);  // takes 50ms to read
    tcs.setInterrupt(true);  // turn LED

    float red, green, blue;
    tcs.getRGB(&red, &green, &blue);

    payload[0] = (uint8_t) 1;

    // le ballon est rouge
    if (red > green && red > blue) {
      payload[1] = (uint8_t) 0;
}
    // le ballon est vert
    if (green > red && green > blue) {
      payload[1] = (uint8_t) 1;
    }

    // le ballon est bleu
    if (blue > red && blue > green) {
      payload[1] = (uint8_t) 2;
}