python
class ScooterEnv(gym.Env):
    """
    Observations:
    - Speed
    - Inclination
    - Battery level
    - Obstacle distance
    - Motor RPM
    - Motor temperature

    Actions:
    - Acceleration
    - Braking
    - Steering angle
    """The important part isn't simply putting an AI model on a scooter.

The interesting challenge is creating a simulation environment where the model can safely learn before deployment.

🧭 MIGHTY: Real-Time Trajectory Planning

Urban Lab also experiments with MIGHTY, an open-source trajectory-planning system.

The idea is to combine perception, localization and trajectory generation to create smoother navigation.

The architecture includes:

Visual-Inertial Odometry
Depth estimation
3D mapping
Trajectory optimization
Real-time obstacle avoidance

The project documentation describes a target architecture where trajectory generation runs continuously as the vehicle moves.

A simplified example:

mighty = MightySimulator()

mighty.add_obstacle(3.0, 2.0, 1.0)
mighty.set_goal(10.0, 5.0)

while not goal_reached:
    mighty.compute_trajectory()
    mighty.avoid_obstacles()
    mighty.move(dt=0.1)

This creates an interesting separation of responsibilities:

RL learns behaviour.

Trajectory planning determines where to go.

The embedded controller executes the commands.

📡 ESP32: Connecting the Physical World

The ESP32 acts as the embedded control layer.

The prototype monitors information such as:

Speed
Battery
Temperature
GPS position
Movement state
Lock state

A simplified firmware structure looks like this:

struct ScooterState {
    float speed = 0;
    float battery = 100;
    float temperature = 25;

    float gpsLat = 44.0576;
    float gpsLon = 12.5653;

    bool isMoving = false;
    bool isLocked = false;
};

The firmware continuously reads sensors, updates the system state and communicates with the application layer.

📱 Mobile Application

Urban Lab also includes a React Native control application.

The application is designed to communicate with the scooter through Bluetooth Low Energy.

Example:

const connectDevice = async (device) => {
    const connectedDevice = await device.connect();

    await connectedDevice
        .discoverAllServicesAndCharacteristics();

    const data = await readCharacteristic();

    setScooterData(parseData(data));
    setConnected(true);
};

This provides the foundation for a future user interface for monitoring and controlling the prototype.

🌐 Web Dashboard

The project also includes a real-time dashboard.

The interface can expose information such as:

<div class="card">
    <div class="card-icon">⚡</div>
    <div class="card-label">Speed</div>
    <div class="card-value" id="speed">
        0.0 km/h
    </div>
</div>

<div class="card">
    <div class="card-icon">🔋</div>
    <div class="card-label">Battery</div>
    <div class="card-value" id="battery">
        100%
    </div>
</div>

The idea is to provide a single interface for observing the physical system in real time.

🏗️ Project Structure

The repository is organized around the different layers of the system:

urban-lab-scooter/
├── 3d-printing/
│   ├── stl-files/
│   ├── slicer-profiles/
│   └── assembly-guide.md
│
├── rl/
│   ├── environments/
│   ├── configs/
│   └── scripts/
│
├── mighty/
│   ├── configs/
│   └── scripts/
│
├── firmware/
├── app/
└── docs/

This structure keeps mechanical design, machine learning, trajectory planning, firmware and applications separated while allowing them to communicate through defined interfaces.

🗺️ Development Roadmap

The project follows several development phases:

Phase   Duration    Activity
1   2 weeks CAD and 3D design
2   2 weeks 3D printing
3   1 week  Hardware assembly
4   2 weeks Software and firmware
5   2 weeks AI and Reinforcement Learning
6   1 week  MIGHTY integration
7   1 week  Testing and calibration

The current roadmap includes final assembly and road testing as subsequent steps.

🤝 Open Source by Design

Urban Lab is intended to be an open-source project.

There are several ways to contribute:

🐛 Bug reports

💡 Feature proposals

🔧 Firmware and software

🖨️ 3D-print testing

📝 Documentation

The goal is not only to build a scooter, but to create a platform where other developers, makers and researchers can experiment with the same technologies.

🔗 Resources
Urban Lab

https://github.com/DanielIoni-creator/urban-lab

Telekinesis RLbotics

https://github.com/telekinesis-ai/telekinesis-rlbotics

MIGHTY

https://github.com/mit-acl/mighty

MyZubster

https://myzubster.org

🚀 What's Next?

The next development steps include:

🔧 Final mechanical assembly
🧪 Hardware testing
🛴 Controlled prototype testing
🤖 Further RL training
🧭 Trajectory-planning experiments
📊 More sensor data
📱 Improvements to the mobile application
🌐 Dashboard improvements

The long-term objective is to build a robust experimental platform for AI-assisted sustainable mobility.

🌱 Final Thoughts

Urban Lab is more than an electric scooter.

It's an experiment in what happens when open-source hardware, AI, robotics and digital manufacturing meet in the real world.

The project started from a simple question:

What if we could build the mobility technology we want to use instead of simply buying it?

Urban Lab is our attempt to answer that question.

And we're building it openly.

🏭 Urban Lab — Open source technology for sustainable mobility.

⭐ If you're interested in the project, check out the repository, experiment with the code and contribute.

#️⃣ Tags

#3DPrinting #ReinforcementLearning #OpenSource #Robotics