Skip to the content
4 layers54.1 × 57 mmProjet Robot, the printed circuit board in 3D

Professional firmware and hardware design for an autonomous mobile robot using STM32G431 and FreeRTOS. Features Lidar perception, ToF safety algorithms, and PID motor control.

Size
54.1 × 57 mm
Copper layers
4
Thickness
1.6 mm
Parts
88
Nets
77
Pads
341
Tracks, vias
609, 113
Pours
8
Routed
Yes
KiCad
KiCad 9.0 (file 20241229)
Created
10 Feb 2026
Updated
7 Sep 2026

Overview

Projet Robot is an open-source printed circuit board by ezer-soltani, from the ezer-soltani/HellKitty-Autonomous-Robot repository on GitHub, published under the MIT licence. It is a 4-layer board of 54.1 × 57 mm with 88 parts on 77 nets, routed with 609 tracks and 113 vias.

It is built around the MP1475DJ-LF-P, ZXBM5210-SP and ADXL343BCCZ-RL, with the 1101M2S3CQE2 and BU33SD5WG-TR among its other parts. Its parts include 33 capacitors, 15 resistors, 5 diodes, 3 ICs and 2 connectors. It belongs with the robots and motor control boards and the STM32 boards of this library.

Main components

5

README

README.md

🐱 HellKitty — Autonomous Combat Mobile Robot

High-Performance Embedded Robotics Platform: STM32G431 (ARM Cortex-M4F @ 170MHz) | FreeRTOS Real-Time Architecture | Custom 4-Layer PCB

HellKitty Autonomous Mobile Robot

STM32G431 FreeRTOS KiCad 4-Layer PCB C99 [blocked] MIT License


⚡ Executive Engineering Summary

HellKitty is an industrial-grade autonomous combat robot engineered for high-speed table-top arena navigation ("Cat & Mouse" adversarial game logic). Designed from bare silicon up to deterministic application-layer control, the platform combines custom 4-layer power/signal mixed PCB hardware, bare-metal C peripheral drivers, and a preemptive FreeRTOS real-time architecture.

The robot executes simultaneous 360° laser perception (YDLIDAR X2 @ 115.2 kbps via DMA), 4-quadrant edge/void Time-of-Flight monitoring (VL53L0X @ 100 Hz), high-G collision detection (ADXL343 accelerometer), dual closed-loop velocity PID regulation (TIM2/TIM4 hardware encoder quadrature decoding @ 100 Hz), and dynamic state-machine tactical transitions under strict deterministic latency constraints.

text
+----------------------------------------------------------------------------------------------------+
|                                    HELLKITTY SYSTEM BENCHMARKS                                     |
+--------------------------+-------------------------------------------------------------------------+
| Core Frequency           | 170 MHz (ARM Cortex-M4F with hardware FPU & DSP instructions)           |
| Control Loop Frequency   | 100 Hz deterministic periodic execution (vTaskDelayUntil)               |
| Edge Safety Latency      | < 10 ms hardware-level emergency stop & auto-evacuation override        |
| LiDAR Data Stream        | Circular DMA buffer (1024 B) with zero-copy packet state-machine parser |
| Sensor Bus Topology      | I2C1 (Fast Mode 400 kHz) with FreeRTOS Mutex Priority Inheritance       |
| Dynamic Power Delivery   | 5.5V-12V input -> 5V @ 3A Buck (MP1475) -> 3.3V Low-Noise LDO (BU33SD5)  |
| Motor Control Drive      | Dual ZXBM5210-SP H-Bridges (3A peak, dynamic braking, 20 kHz PWM)       |
+--------------------------+-------------------------------------------------------------------------+

🏗️ System Architecture

The robot's firmware and hardware layers are decoupled through strict hardware abstraction and thread-safe real-time communication mechanisms:

mermaid
graph TD
    %% Subsystem Grouping
    subgraph SENSORS["Perception & Telemetry Hardware"]
        LIDAR["YDLIDAR X2\n(360° 2D Laser Rangefinder)"]
        TOF["4x VL53L0X ToF\n(Quadrants: FL, FR, RL, RR)"]
        IMU["ADXL343\n(3-Axis Accelerometer)"]
        ENC["2x Quadrature Encoders\n(2048 CPR / Wheel)"]
        BT["HC-05 Bluetooth\n(Telemetry / Remote Shell)"]
    end

    subgraph HARDWARE_IF["STM32G431 Microcontroller Peripherals"]
        UART2_DMA["USART2 + Circular DMA\n(115200 baud, 1024B Buffer)"]
        I2C1_BUS["I2C1 Fast Mode (400kHz)\n(Addresses: 0x54, 0x56, 0x58, 0x5A, 0xA6)"]
        TIM_ENC["TIM2 (32-bit) & TIM4 (16-bit)\nHardware Encoder Interface Mode"]
        UART3_IT["USART3 RX Interrupt\n(Byte-by-byte parser)"]
        TIM3_PWM["TIM3 4-Channel PWM\n(20 kHz Motor Drive)"]
        GPIO_CTRL["GPIO Output / Status LEDs\n(XSHUT, Brake, Status LEDs)"]
    end

    subgraph RTOS_LAYER["FreeRTOS Preemptive Kernel"]
        MUTEX_I2C{{"xI2C1Mutex\n(Priority Inheritance)"}}
        MUTEX_UART{{"xUARTMutex\n(Thread-Safe Printf)"}}
        
        TASK_SAFETY["vSafetyTask\n(Priority 3 | 100 Hz)\nEdge Void & Fault Protection"]

⏱️ FreeRTOS Multitasking & Real-Time Scheduling

The firmware uses FreeRTOS v10.3.1 with dynamic memory allocation, preemptive scheduling, and priority-inheritance mutexes to guarantee deterministic timing across all subsystems.

Task Execution Matrix

Task NamePriorityPeriodicity / TriggerStack SizeShared Resources / IPCFunctional Responsibility
vControlTask4 (Highest)100 Hz (10 ms)
vTaskDelayUntil
512 words
(2048 B)
Hardware Timers (TIM2/3/4), Target Speeds (target_speed_lin_x, target_speed_ang_z)Reads wheel encoders, updates Runge-Kutta odometry, executes dual velocity PID loops with integral anti-windup, computes PWM duty cycles, and applies motor ramping.
vSafetyTask3 (High)100 Hz (10 ms)
Continuous Polling
256 words
(1024 B)
xI2C1Mutex, g_safety_override, STATUS_SOURIS_LEDPolls 4x VL53L0X ToF range registers. If distance to table surface exceeds 200 mm (void/cliff detected), asserts atomic override flag, cuts motor PWM, and commands automated pivot-and-reverse escape trajectory.
vLidarTask2 (Normal)10 Hz (100 ms)
(DMA Polled @ 100 Hz)
512 words
(2048 B)
huart2 Circular DMA buffer, xUARTMutex, g_targetProcesses raw bytes from circular DMA, validates packet headers (0xAA 0x55) and XOR checksums, performs geometric angle correction, clusters contiguous obstacle points, and tracks closest target.
vImuTask1 (Low)20 Hz (50 ms)
Periodic Delay
256 words
(1024 B)
xI2C1Mutex, Strategy_ToggleRole()Reads ADXL343 3-axis acceleration registers over I2C. Evaluates hardware SINGLE_TAP shock interrupt (>3.5G threshold) with 2000 ms debounce to switch between Cat (Predator) and Mouse (Prey) combat states.

Shared Resource Arbitration & Synchronization

c
// Example: Thread-safe I2C bus acquisition with Priority Inheritance
if (xSemaphoreTake(xI2C1Mutex, portMAX_DELAY) == pdTRUE) {
    status = ADXL343_ReadAxes(&hi2c1, &accel_data);
    if (ADXL343_CheckShock(&hi2c1) && g_safety_override == 0) {
        shock_detected = 1;
    }
    xSemaphoreGive(xI2C1Mutex);
}
  1. I2C1 Bus Contention: The xI2C1Mutex protects the single I2C peripheral shared between the 4x VL53L0X ToF rangefinders and the ADXL343 IMU. Priority inheritance guarantees that if the low-priority vImuTask holds the bus when vSafetyTask wakes up, vImuTask temporarily inherits Priority 3, preventing unbounded priority inversion.
  2. LiDAR Circular DMA Buffer: Direct Memory Access on USART2 writes directly to a 1024-byte SRAM ring buffer without CPU interrupt thrashing. The task tracks hardware CNDTR counter offsets to parse complete frames asynchronously.
  3. Safety Override Interlock: An atomic flag g_safety_override decouples normal FSM navigation from the anti-fall maneuver. When asserted, vControlTask suspends trajectory setpoints until the robot returns to safe bounds.

🖨️ Hardware Design & Custom 4-Layer PCB

The robot is built around a custom 4-layer impedance-controlled PCB engineered in KiCad 9.0, optimized for high current density, low EMI, and clean power distribution.

4-Layer PCB 3D CAD Model

PCB Layer Stackup (1.6 mm Total Thickness, FR4)

LayerNameTypeCopper ThicknessDielectric SpacingFunctional Allocation
L1F.Cu (Top)Signal35 µm (1 oz)—High-speed digital signals (SWD, USART, I2C, SPI), MCU breakout, sensor connectors.
—Dielectric 1Prepreg (FR4)—0.10 mm ((\varepsilon_r = 4.5))High capacitive coupling to ground plane.
L2In1.Cu (Inner 1)Power / Plane35 µm (1 oz)—Continuous Solid Ground Plane (GND) for unbroken return current paths and EMI reduction.
—Dielectric 2Core (FR4)—1.24 mm ((\varepsilon_r = 4.5))Structural core isolation.
L3In2.Cu (Inner 2)Power / Plane35 µm (1 oz)—Power Distribution Plane (PWR): Split polygon pours for +5V, +3.3V, and VBAT.
—Dielectric 3Prepreg (FR4)—0.10 mm ((\varepsilon_r = 4.5))High capacitive coupling to bottom layer.
L4B.Cu (Bottom)Signal35 µm (1 oz)—High-current motor H-bridge power routing, thermal relief dissipation, and test points.

Component & Power Distribution Architecture

SubsystemComponent / ICInterfaceSpecifications & Operational Role
MCUSTM32G431CBU6 (UFQFPN48)SWD / STDC14ARM Cortex-M4F @ 170 MHz, 128 KB Flash, 32 KB SRAM, hardware FPU/DSP, CORDIC math unit.
Step-Down BuckMPS MP1475DJ-LF-PSwitching Reg500 kHz synchronous buck converter converting 2S/3S LiPo battery (7.4V–11.1V) to a stable 5.0V @ 3.0A rail.
Low-Noise LDOROHM BU33SD5WG-TRLinear RegHigh PSRR, ultra-low dropout linear regulator stepping down 5.0V to 3.3V for MCU core and analog peripherals.
Motor Drivers2x Diodes Inc. ZXBM5210-SPTIM3 PWM / GPIOReversible H-Bridge drivers (3V–18V, 0.85A continuous, 3.0A peak, SOIC-8EP) with dynamic braking and cross-conduction protection.
LiDAR SensorYDLIDAR X2USART2 + DMA360° 2D triangulation laser rangefinder (8 Hz rotational scan frequency, 0.12m–8.0m range, 3 kHz sample rate).
Cliff / ToF Array4x STMicroelectronics VL53L0XI2C1 + 4x XSHUTTime-of-Flight ranging sensors dynamically re-addressed (0x54, 0x56, 0x58, 0x5A) for four-corner table edge monitoring.
IMU / ShockAnalog Devices ADXL343BCCZI2C1 + INT23-axis ultra-low power digital accelerometer configured for SINGLE_TAP interrupt capture (>3.5G collision detection).
Encoders2x Quadrature Optical/MagneticTIM2 / TIM4Dual-channel differential quadrature encoder feedback (2048 counts per wheel revolution in 4x mode).
Telemetry / CommsHC-05 Bluetooth ModuleUSART3 @ 9600bdBidirectional UART telemetry bridge for real-time telemetry streaming and remote state control.

KiCad Schematic Sheet Index

The complete schematic design is partitioned into modular hierarchical sheets inside hardware/:

Schematic SheetSource FileDescription
Root Top SheetProjet_Robot.kicad_schTop-level interconnections, hierarchical bus links, and module connectors.
MCU & Clocksµcontrolleur.kicad_schSTM32G431 pinout, STDC14 debug connector, external 8 MHz crystal, bypass capacitors, and status LEDs.
Power Regulatorsregulateurs.kicad_schMP1475 buck regulator, BU33SD5 LDO, LC output filtering, reverse-polarity protection, and slide power switch.
Sensor Arraycapteur.kicad_sch4x VL53L0X ToF connectors with XSHUT lines, ADXL343 accelerometer layout, and YDLIDAR / HC-05 headers.
Motor Driver 1 & 2moteur1.kicad_schDual ZXBM5210-SP H-Bridges, flyback suppression capacitors, test points, and JST-XH encoder/motor connectors.

💻 Low-Level Driver & Algorithmic Implementation

1. YDLIDAR X2 Circular DMA Driver & Packet Parsing

The LiDAR stream transmits continuous variable-length point frames at 115200 baud over USART2. To eliminate CPU byte-by-byte interrupts, DMA operates in circular ring-buffer mode (LIDAR_DMA_BUFFER_SIZE = 1024):

c
// Zero-overhead ring buffer processing in vLidarTask
uint16_t pos = LIDAR_DMA_BUFFER_SIZE - __HAL_DMA_GET_COUNTER(huart2.hdmarx);
if (pos != old_pos) {
    if (pos > old_pos) {
        ydlidar_process_data(&lidar_dma_buffer[old_pos], pos - old_pos);
    } else {
        ydlidar_process_data(&lidar_dma_buffer[old_pos], LIDAR_DMA_BUFFER_SIZE - old_pos);
        if (pos > 0) ydlidar_process_data(&lidar_dma_buffer[0], pos);
    }
    old_pos = pos;
}
Frame Decoding State Machine & Validation
  1. Header Synchronization: Scans for sequence 0xAA 0x55.
  2. Header Parsing: Reads Packet Type (CT), Sample Count (LSN), First Sample Angle (FSA), and Last Sample Angle (LSA).
  3. XOR Checksum Verification: Computes 16-bit folded XOR checksum over the full packet structure and rejects corrupted frames: $$\text{Checksum} = \bigoplus_{i=0}^{N-1} \text{Word}_i$$
  4. Geometric Angle Correction: Corrects triangulation parallax distortion for near-field obstacles: $$\theta_{\text{corrected}} = \theta_{\text{raw}} + \arctan\left(21.8 \cdot \frac{155.3 - d}{155.3 \cdot d}\right) \cdot \frac{180^\circ}{\pi}$$
  5. Spatial Clustering & Object Discrimination: Contiguous points with spatial distance variation $< \Delta_{\text{thresh}}$ are grouped into object clusters. Physical width is computed via polar chord projection: $$W_{\text{object}} = 2 \cdot d_{\text{avg}} \cdot \tan\left(\frac{\theta_{\text{width}}}{2}\right)$$ Clusters with $50,\text{mm} \le W \le 300,\text{mm}$ and $d \le 1200,\text{mm}$ are classified as adversarial robots; static wall boundaries and arena artifacts are filtered out.

2. Multi-Device Dynamic I2C Bootstrapping (4x VL53L0X)

All four VL53L0X Time-of-Flight sensors power up with the identical default I2C address (0x29 / 0x52). The custom driver performs a deterministic hardware-timed bootstrap:

mermaid
sequenceDiagram
    participant MCU as STM32G431 (Master)
    participant T1 as TOF1 (Front-Right)
    participant T2 as TOF2 (Front-Left)
    participant T3 as TOF3 (Rear-Left)
    participant T4 as TOF4 (Rear-Right)

    Note over MCU,T4: Reset Phase: Drive all XSHUT pins LOW
    MCU->>T1: XSHUT1 = 0
    MCU->>T2: XSHUT2 = 0
    MCU->>T3: XSHUT3 = 0
    MCU->>T4: XSHUT4 = 0
    MCU->>MCU: Delay 20ms

    Note over MCU,T1: Stage 1: Initialize TOF 1
    MCU->>T1: XSHUT1 = 1 (Wake up)
    MCU->>T1: Write Reg 0x8A -> Re-address to 0x54
    MCU->>T1: Load Calibration & Start Continuous Mode

    Note over MCU,T2: Stage 2: Initialize TOF 2
    MCU->>T2: XSHUT2 = 1 (Wake up)
    MCU->>T2: Write Reg 0x8A -> Re-address to 0x56
    MCU->>T2: Load Calibration & Start Continuous Mode

3. Closed-Loop Motion Control, Odometry & State Machine

text
              +-------------------------------------------------------------+
              |                      STRATEGY FSM                           |
              |       (SEARCH -> ATTACK [Cat] / FLEE [Mouse])               |
              +-------------------------------------------------------------+
                                   |                     |
                      v_lin (target_speed_lin_x)    v_ang (target_speed_ang_z)
                                   |                     |
                                   v                     v
              +-------------------------------------------------------------+
              |                DIFFERENTIAL KINEMATICS                      |
              |  ω_L = (v_lin - v_ang * L/2) / R                            |
              |  ω_R = (v_lin + v_ang * L/2) / R                            |
              +-------------------------------------------------------------+
                         |                                  |
                   Target ω_L                         Target ω_R
                         |                                  |
                         v                                  v
              +--------------------+             +--------------------+
              |  PID LEFT (Motor2) |             | PID RIGHT (Motor1) |
              |  Kp=5.0, Ki=20.0   |             | Kp=5.0, Ki=20.0    |
              |  Anti-Windup Clamped|             | Anti-Windup Clamped|
              +--------------------+             +--------------------+
                         |                                  |
                     PWM_Duty_L                         PWM_Duty_R
Parallel PID Velocity Control with Anti-Windup

$$\text{Output}(t) = K_p \cdot e(t) + K_i \int_0^t e(\tau),d\tau + K_d \frac{de(t)}{dt}$$

To prevent integrator windup during motor saturation or abrupt stops: $$\text{Integral}{\text{clamped}} = \max\left(-\text{Max}{\text{int}}, \min\left(\text{Max}_{\text{int}}, \text{Integral} + e(t) \cdot \Delta t\right)\right)$$

Runge-Kutta / Midpoint Odometry Position Integration

Wheel speeds (\omega_L, \omega_R) are converted to linear displacement at (\Delta t = 10,\text{ms}): $$v_{\text{robot}} = \frac{v_R + v_L}{2}, \quad \omega_{\text{robot}} = \frac{v_R - v_L}{L_{\text{track}}}$$ $$\Delta \theta = \omega_{\text{robot}} \cdot \Delta t, \quad \theta_{\text{mid}} = \theta_k + \frac{\Delta \theta}{2}$$ $$x_{k+1} = x_k + v_{\text{robot}} \cdot \cos(\theta_{\text{mid}}) \cdot \Delta t$$ $$y_{k+1} = y_k + v_{\text{robot}} \cdot \sin(\theta_{\text{mid}}) \cdot \Delta t$$ $$\theta_{k+1} = \theta_k + \Delta \theta \pmod{2\pi}$$


🛠️ Build, Flash & Deployment Guide

Hardware Requirements

  • Target Hardware: HellKitty Custom PCB (with STM32G431CBU6)
  • Debugger / Programmer: ST-Link V2 / V3 or J-Link (via standard SWD STDC14 connector)
  • Power Supply: 2S LiPo Battery (7.4V) or Benchtop Power Supply (7.0V–12.0V, 3A limit)

Software & Toolchain Prerequisites

  • Toolchain: arm-none-eabi-gcc (v10.3 or higher)
  • IDE: STM32CubeIDE (v1.14.0+) or VS Code with Cortex-Debug / CMake
  • Flashing Tools: STM32CubeProgrammer, openocd, or st-flash
  • Telemetry Visualizer: Python 3.8+ (pyserial, matplotlib, numpy)

Step-by-Step Compilation & Flashing

Option A: Using STM32CubeIDE (GUI)
  1. Launch STM32CubeIDE and select File -> Import -> Existing Projects into Workspace.
  2. Browse to the cloned firmware/ directory and click Finish.
  3. Select the build configuration (Release or Debug).
  4. Click Project -> Build All (Ctrl+B).
  5. Connect your ST-Link to the onboard STDC14 connector, then click Run -> Run (Ctrl+F11).
Option B: Using Command Line & OpenOCD (CLI)
bash
# 1. Clone the repository
git clone https://github.com/ezer-soltani/HellKitty-Autonomous-Robot.git
cd HellKitty-Autonomous-Robot

# 2. Flash binary via OpenOCD with ST-Link
openocd -f interface/stlink.cfg -f target/stm32g4x.cfg \
        -c "program firmware/Debug/Firmware_Robot.elf verify reset exit"

# Alternatively, using STM32CubeProgrammer CLI:
STM32_Programmer_CLI -c port=SWD -w firmware/Debug/Firmware_Robot.bin 0x08000000 -v -rst

Real-Time LiDAR Visualizer & Telemetry Setup

A custom Python polar visualizer is included in scripts/visualizer.py for real-time laser point-cloud streaming over serial:

bash
# Install visualizer dependencies
pip install pyserial matplotlib numpy

# Run the real-time visualizer (adjust port to your serial device, e.g. COM3 or /dev/ttyUSB0)
python scripts/visualizer.py

LiDAR Output Visualization

Remote Shell & Bluetooth Command Protocol

Connect via Bluetooth terminal (HC-05 @ 9600 baud) or ST-Link Virtual COM Port (USART1 @ 115200 baud):

Command StringFirmware HandlerAction Performed
START\nStrategy_SetEnabled(1)Enables motor outputs and activates the Strategy FSM.
STOP\nStrategy_SetEnabled(0)Emergency stop: forces motor PWM to 0% and clears setpoints.
CHAT\nStrategy_SetRole(ROLE_CHAT)Manually sets combat mode to Cat (Predator). Green LED on.
SOURIS\nStrategy_SetRole(ROLE_SOURIS)Manually sets combat mode to Mouse (Prey). Red LED on.

📂 Repository Structure

text
HellKitty-Autonomous-Robot/
├── firmware/                       # Embedded STM32 Firmware
│   ├── Core/
│   │   ├── Drivers/                # Custom Bare-Metal / HAL Component Drivers
│   │   │   ├── hc-05_bluetooth.c/h # Bluetooth command interpreter & telemetry
│   │   │   ├── imu.c/h             # ADXL343 I2C driver & shock interrupt config
│   │   │   ├── lidar.c/h           # YDLIDAR X2 DMA parser & object clustering
│   │   │   ├── motor.c/h           # H-Bridge PWM & hardware encoder interface
│   │   │   ├── odometry.c/h        # Runge-Kutta differential drive odometry
│   │   │   ├── pid.c/h             # Closed-loop velocity PID with anti-windup
│   │   │   └── tof.c/h             # 4x VL53L0X dynamic I2C bootstrap driver
│   │   ├── Inc/                    # Application Headers & Peripheral Configs
│   │   │   ├── FreeRTOSConfig.h    # Kernel configuration (Preemption, Heap, Priorities)
│   │   │   ├── main.h              # Pin definitions & hardware clock mappings
│   │   │   └── strategy.h          # FSM state declarations & game logic
│   │   └── Src/                    # RTOS Tasks & HAL Peripheral Initialization
│   │       ├── app_freertos.c      # FreeRTOS task implementations & mutex definitions
│   │       ├── main.c              # System initialization & clock tree setup (170MHz)
│   │       └── strategy.c          # Tactical FSM (SEARCH / ATTACK / FLEE)
│   ├── Drivers/                    # STMicroelectronics CMSIS & G4 HAL Drivers
│   ├── Middlewares/                # FreeRTOS Real-Time Kernel Source Code
│   ├── Firmware_Robot.ioc          # STM32CubeMX Hardware Configuration Project
│   └── STM32G431CBUX_FLASH.ld      # GCC Linker Script (Memory Map layout)
├── hardware/                       # KiCad 9.0 Electronic CAD Project

👨‍💻 Engineering Team & Contributors

Developed at ENSEA (Graduate School of Electrical and Computer Engineering) within the Electronics & Embedded Systems (ESE) department:

  • Ezer Soltani — Embedded Software & Firmware Lead (FreeRTOS, Drivers, Control & Odometry) — GitHub
  • Aymen Ben Jemaa — Hardware & PCB Design Engineer (KiCad 4-Layer Board, Power Delivery) — GitHub
  • Serine Rouabah — Perception, Sensor Integration & Algorithm Development — GitHub

📜 License

This project is licensed under the MIT License — see the LICENSE file for complete details.

Parts

88
QtyValueFootprintReferences
16100nCapacitor_SMD:C_0402_1005MetricC1, C5, C6, C7, C9, C11, C15, C16, C17, C21, C22, C23, C24, C25, C32, C33
81uCapacitor_SMD:C_0603_1608MetricC12, C13, C26, C27, C28, C29, C30, C31
7TestPointTestPoint:TestPoint_Pad_D1.5mmTP_PWM_1_2, TP1, TP2, TP3, TP6, TP7, TP8
5Conn_01x06Connector_PinSocket_2.54mm:PinSocket_1x06_P2.54mm_VerticalBluetooth1, TOF1, TOF2, TOF3, TOF4
5LED_SmallLED_SMD:LED_0603_1608MetricD1, D2, D3, D4, D5
4MountingHole_PadMountingHole:MountingHole_3.2mm_M3_Pad_ViaH1, H2, H3, H4
322uCapacitor_SMD:C_0805_2012MetricC14, C18, C20
2100KResistor_SMD:R_0603_1608MetricR7, R9
210pCapacitor_SMD:C_0402_1005MetricC3, C4
22k2Resistor_SMD:R_0603_1608MetricR1, R2
2600Resistor_SMD:R_0603_1608MetricR3, R4
2Conn_01x06Connector_JST:JST_XH_S6B-XH-A_1x06_P2.50mm_HorizontalMotor1, Motor2
2SW_PushKiCad:SW Push 1P1T NO 6x6mm H9.5mmch/sou1, SW1
2ZXBM5210-SPPackage_SO:Diodes_SO-8EPM1, M2
110KResistor_SMD:R_0603_1608MetricR20
110kResistor_SMD:R_0603_1608MetricR17
110nCapacitor_SMD:C_0603_1608MetricC8
110uCapacitor_SMD:C_0603_1608MetricC10
11101M2S3CQE2KiCad:1101M2S3QE2S1
115pCapacitor_SMD:C_0402_1005MetricC19
116MHzCrystal:Crystal_SMD_EuroQuartz_MT-4Pin_3.2x2.5mmY1
116kResistor_SMD:R_0603_1608MetricR11
11k6Resistor_SMD:R_0603_1608MetricR14
120kResistor_SMD:R_0603_1608MetricR10
12k3Resistor_SMD:R_0603_1608MetricR5
139nInductor_SMD:L_0603_1608MetricL1
140k2Resistor_SMD:R_0603_1608MetricR13
14k5Resistor_SMD:R_0603_1608MetricR6
14u7Inductor_SMD:L_APV_ANR5040L2
14u7Capacitor_SMD:C_0603_1608MetricC2
17K68Resistor_SMD:R_0603_1608MetricR12
1ADXL343BCCZ-RLPackage_LGA:LGA-14_3x5mm_P0.8mm_LayoutBorder1x6yIC1
1BU33SD5WG-TRPackage_SO:TSOP-5_1.65x3.05mm_P0.95mmPS1
1Conn_01x05Connector_JST:JST_XH_B5B-XH-A_1x05_P2.50mm_VerticalLidar1
1Conn_Battery_CellConnector_JST:JST_EH_B2B-EH-A_1x02_P2.50mm_VerticalJ1
1Conn_ST_STDC14Connector_PinHeader_1.27mm:PinHeader_2x07_P1.27mm_Vertical_SMDJ11
1LKiCad:logo helloHelloKitty
1LOGOLOGOG***
1MP1475DJ-LF-PPackage_TO_SOT_SMD:TSOT-23-8_HandSolderingIC2
1STM32G431CBUxPackage_DFN_QFN:QFN-48-1EP_7x7mm_P0.5mm_EP5.6x5.6mmU1

Similar boards

  • 8 layers45 × 45 mmPCB Projet ESE v2, the printed circuit board in 3D

    PCB Projet ESE v2

    FernandesVincent/Projet-ESE-chat-robot

    Création d'un robot jouant à chat.

    218 parts
  • 4 layers54 × 57 mmStealthKitty.kicad pro, the printed circuit board in 3D

    StealthKitty.kicad pro

    flexdrt/2425_ESE_Projet_StealthKitty

    Ce projet est réalisé dans le cadre de la dernière année de la filière électronique et systèmes embarqués (ESE) de l'ENSEA.

    82 parts
  • 4 layers90 × 72 mmRobot, the printed circuit board in 3D

    Robot

    Dorian12000/Projet

    robot chat

    62 parts1
  • 4 layers90 × 72 mmRobot chat, the printed circuit board in 3D

    Robot chat

    HOSTEER/ESE2024

    Activer doxygen dans les propriétés du projet -> général C/C++, tuto doxygen https://www.youtube.com/watch?v=GC9Xy7nLxyw

    112 parts
  • 4 layers54 × 57 mmTagBot, the printed circuit board in 3D

    TagBot

    exysta/2425_ESE_Projet_TagBot

    Vous vous trouvez actuellement dans le projet TagBot (ou robot chat), qui s'intègre à un projet de classe où chaque équipe doit concevoir un robot.

    87 parts3MIT
  • 4 layers57 × 54 mmPojet V NOM KiCAD, the printed circuit board in 3D

    Pojet V NOM KiCAD

    MohamedBenabdelhadi/2425_ESE_Projet_V-NOM

    Mohamed Benabdelhadi_Nouhaila Faris_Oliver Belliard_Valerian Priou

    78 parts2
  • 4 layers54 × 57 mmProjet torero, the printed circuit board in 3D

    Projet torero

    Manassehalt/2425_ESE_Projet_Torero

    Projet de 3ème année d'ESE réalisé par : - JACQUOT Nolan - GUIFFAULT Gabriel - BOULOT Paul - THOMAR Jean-Philippe

    82 parts
  • 4 layers88 × 68 mmGc STM32G491CET6, the printed circuit board in 3D

    Gc STM32G491CET6

    lfiack/gCollector

    Garbage collector robot for FreeRTOS Labs

    83 parts

Questions

How big is the Projet Robot PCB?

It measures 54.1 × 57 mm and has 4 copper layers, 1.6 mm thick.

What parts does the Projet Robot use?

88 parts, built around the MP1475DJ-LF-P, ZXBM5210-SP, ADXL343BCCZ-RL and 1101M2S3CQE2. The full list of its parts is on this page, with links to each part's symbol and footprint where PCBKit's library has them.

Where can I download the Projet Robot KiCad files?

From the ezer-soltani/HellKitty-Autonomous-Robot repository on GitHub, at the commit this page was made from: the board is hardware/Projet_Robot.kicad_pcb and its schematic hardware/Projet_Robot.kicad_sch. PCBKit opens the board in the browser, with nothing to install.

Can I use the Projet Robot design in my own project?

Its repository publishes it under the MIT licence: you may reuse it on that licence's terms (keep the author's notice, and for a copyleft licence share your changes alike).