text
             ┌─────────────────────┐
             │   Scooter Sensors   │
             │ IMU / GPS / Battery │
             └──────────┬──────────┘
                        │
                        ▼
             ┌─────────────────────┐
             │  Simulation / RL    │
             │      Training       │
             └──────────┬──────────┘
                        │
                        ▼
             ┌─────────────────────┐
             │   Trained Policy    │
             │   ONNX / Runtime    │
             └──────────┬──────────┘
                        │
                        ▼
             ┌─────────────────────┐
             │   Edge Controller   │
             │       ESP32         │
             └──────────┬──────────┘
                        │
                        ▼
             ┌─────────────────────┐
             │ Motor / Brake / I/O │
             └─────────────────────┘
The important principle is to keep the training environment separated from the physical vehicle.

📦 Technology Stack

The experimental software stack includes:

Python
Gymnasium
PyTorch
ONNX
ONNX Runtime
ESP32
C/C++
React Native

Where appropriate, RL libraries can be evaluated and integrated during development.

🧪 Simulation Environment

A simplified Gymnasium environment could represent the scooter using observations such as:

class ScooterEnv(gym.Env):
    """
    Example observation space:

    - speed
    - inclination
    - battery level
    - obstacle distance
    - motor RPM
    - motor temperature

    Example actions:

    - acceleration
    - braking
    - steering
    """

    def __init__(self):
        super().__init__()

    def reset(self, seed=None, options=None):
        pass

    def step(self, action):
        pass

The simulation environment is important because it allows us to test policies before considering physical deployment.

🚀 PPO Training

One possible algorithm for experimentation is Proximal Policy Optimization (PPO).

Example configuration:

algorithm:
  name: PPO
  learning_rate: 0.0003
  n_steps: 2048
  batch_size: 64
  n_epochs: 10
  gamma: 0.99
  gae_lambda: 0.95
  clip_range: 0.2

network:
  architecture: mlp
  hidden_layers:
    - 256
    - 256
    - 128
  activation: tanh

training:
  total_timesteps: 1000000

These values are starting points for experimentation rather than guaranteed optimal parameters.

🖨️ 3D Printing

3D printing is another important part of Urban Lab.

Potential printed components include:

Component   Material
Electronics enclosure   PETG
ESP32 mount PLA/PETG
Battery enclosure prototype PETG
Cable management    TPU
Mudguards   TPU
Mechanical prototypes   PETG/ABS

Structural components must be properly engineered and validated before being used in a vehicle.

📡 Sensors & Electronics

The experimental architecture includes:

Sensor  Example Purpose
GPS NEO-6M  Position
IMU MPU6050 Motion
Proximity   HC-SR04 Obstacle detection
NFC RC522   Authentication
Display OLED    Local status

The ESP32 provides a low-cost platform for connecting these components.

💻 ESP32 Firmware

A simplified firmware architecture:

#include <Arduino.h>

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

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

ScooterState scooterState;

void setup() {
    Serial.begin(115200);

    setupSensors();
    setupWiFi();
    setupBLE();
}

void loop() {
    readSensors();
    updateTelemetry();
    checkErrors();

    delay(100);
}

The firmware is designed around a simple pipeline:

Sensors → Processing → Telemetry → Decision Support

📱 Mobile Application

A future mobile application can provide:

Battery monitoring
Vehicle status
Sensor information
BLE connectivity
GPS information
Maintenance notifications
AI-assisted diagnostics

Example:

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

    await connectedDevice
        .discoverAllServicesAndCharacteristics();

    const data = await readCharacteristic();

    setScooterData(parseData(data));
    setConnected(true);
};
🔬 Safety First

A smart vehicle is a safety-critical system.

For that reason, Urban Lab follows an important development principle:

Simulation first. Hardware testing second. Public-road operation only after appropriate safety and regulatory validation.

RL policies should never directly control a real vehicle without appropriate safeguards, limits, emergency controls and extensive validation.

📁 Project Structure
urban-lab-scooter/
│
├── 3d-printing/
│   ├── stl-files/
│   └── slicer-profiles/
│
├── rl/
│   ├── environments/
│   ├── configs/
│   └── scripts/
│
├── firmware/
│
├── app/
│
└── docs/
🚀 Roadmap
Current
✅ Project architecture
✅ Hardware research
✅ 3D-printing development
✅ ESP32 development
🔄 RL experimentation
Next
⏳ Simulation environment
⏳ RL training
⏳ Model evaluation
⏳ Sensor integration
⏳ Edge inference experiments
⏳ Physical prototype testing
Future
🌐 Open datasets
🤖 Improved control policies
📊 Telemetry dashboard
🧠 AI-assisted diagnostics
🛴 Advanced mobility experiments
🤝 Contributing

Urban Lab is an open-source experiment.

You can contribute with:

🧠 AI / ML
🤖 Reinforcement Learning
🔧 Firmware
📡 IoT
🖨️ 3D design
📱 Mobile development
📚 Documentation
🧪 Testing

Issues and pull requests are welcome.

🔗 Projects

Urban Lab

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

MyZubster

https://github.com/myzubster/myzubster

If you're interested in open-source AI, hardware and sustainable technology, follow the development and get involved.

🏁 Final Thoughts

Urban Lab is an experiment at the intersection of:

Open Source × AI × Robotics × IoT × Sustainable Mobility

We're starting with a scooter, but the bigger objective is to build an open environment where hardware and software can evolve together.

Build. Simulate. Test. Improve. Share.

🛴🤖🌱

Urban Lab — Open-source mobility from Rimini.