├── IMG_20201130_125630_1.jpg
├── IMG_20201130_125801_1.jpg
├── IMG_20201130_125918_1.jpg
├── LICENSE
├── README.md
├── analog_joystick.jpeg
├── schematics.png
└── src
    ├── ble_advertising.py
    ├── joystick.py
    ├── joystick_ble.py
    └── main.py


/IMG_20201130_125630_1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/insighio/esp32-microgamepad-ble/658381bc263c03bc18ef986967cf909e24398ea6/IMG_20201130_125630_1.jpg


--------------------------------------------------------------------------------
/IMG_20201130_125801_1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/insighio/esp32-microgamepad-ble/658381bc263c03bc18ef986967cf909e24398ea6/IMG_20201130_125801_1.jpg


--------------------------------------------------------------------------------
/IMG_20201130_125918_1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/insighio/esp32-microgamepad-ble/658381bc263c03bc18ef986967cf909e24398ea6/IMG_20201130_125918_1.jpg


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 insigh.io
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # esp32-microgamepad-ble
 2 | Dual analog joystick on ESP32 over BLE (Nordic UART Service - NUS) using micropython
 3 | 
 4 | The purpose of this project is to create a dual-joystick analog gamepad that will be transmitting over BLE the values using an ESP32 device. 
 5 | It is an ideal controller for robot projects. Joystick 1 is used for steering and Joystick 2 is used for controlling camera movement. 
 6 | 
 7 | # Components
 8 | * ESP32 with micropython firmware
 9 |     * ideally use one of the latest firmwares as BLE was recently supported. Tested with: esp32-idf4-20200902-v1.13.bin
10 | * Breadboard / Prototyping board
11 | * Resistor 10κΩ x2
12 | * Analog Joystick 5-Pin x2
13 | 
14 | ![img](https://github.com/insighio/esp32-microgamepad-ble/blob/main/analog_joystick.jpeg)
15 | 
16 | # Wiring
17 | Allthough the analog joysticks label the input as 5V, they perfectly work with 3.3V which will be used in our schematic. Also J1, J2 will be abreviations for Joystick 1 and Joystick 2. 
18 | 
19 | To enable the digital input of the button click when the joystick is pressed, a resistor of 10kΩ is connected to the 3.3V of the ESP32 one the one hand, and to the respective GPIO where the SW pins of the joystics are connected (GPIO25, GPIO26)
20 | 
21 | | Component PIN | ESP PIN |
22 | | ------------- | ------- |
23 | | J1 5V | 3.3V |
24 | | J2 5V | 3.3V |
25 | | Resistor 1 | 3.3V |
26 | | Resistor 2 | 3.3V |
27 | | J2 GND | GND |
28 | | J1 GND | GND |
29 | | J1 VRx | GPIO34 |
30 | | J1 VRy | GPIO35 |
31 | | J1 SW | GPIO25 |
32 | | J2 VRx | GPIO32 |
33 | | J2 VRy | GPIO33 |
34 | | J2 SW | GPIO26 |
35 | | Resistor 1 | GPIO25 |
36 | | Resistor 2 | GPIO26 |
37 | 
38 | ![complete schematic](https://github.com/insighio/esp32-microgamepad-ble/blob/main/schematics.png)
39 | 
40 | # On Raspberri Pi
41 | An interesting alternative on how to read the analog values of the Joysticks is the use of a Raspberry Pi with an MCP3008 analog-to-digital converter.
42 | 
43 | link: https://tutorials-raspberrypi.com/raspberry-pi-joystick-with-mcp3008/
44 | 
45 | # references
46 | * https://medium.com/@codeyourventurefree/diy-iot-joytick-to-play-online-claw-machines-175206679fc9
47 | * https://esp32.com/viewtopic.php?t=14803
48 | * https://docs.micropython.org/en/latest/library/ubluetooth.html
49 | * https://github.com/micropython/micropython/tree/master/examples/bluetooth
50 | 


--------------------------------------------------------------------------------
/analog_joystick.jpeg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/insighio/esp32-microgamepad-ble/658381bc263c03bc18ef986967cf909e24398ea6/analog_joystick.jpeg


--------------------------------------------------------------------------------
/schematics.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/insighio/esp32-microgamepad-ble/658381bc263c03bc18ef986967cf909e24398ea6/schematics.png


--------------------------------------------------------------------------------
/src/ble_advertising.py:
--------------------------------------------------------------------------------
 1 | 
 2 | from micropython import const
 3 | import struct
 4 | import ubluetooth
 5 | 
 6 | # Advertising payloads are repeated packets of the following form:
 7 | #   1 byte data length (N + 1)
 8 | #   1 byte type (see constants below)
 9 | #   N bytes type-specific data
10 | 
11 | _ADV_TYPE_FLAGS = const(0x01)
12 | _ADV_TYPE_NAME = const(0x09)
13 | _ADV_TYPE_UUID16_COMPLETE = const(0x3)
14 | _ADV_TYPE_UUID32_COMPLETE = const(0x5)
15 | _ADV_TYPE_UUID128_COMPLETE = const(0x7)
16 | _ADV_TYPE_UUID16_MORE = const(0x2)
17 | _ADV_TYPE_UUID32_MORE = const(0x4)
18 | _ADV_TYPE_UUID128_MORE = const(0x6)
19 | _ADV_TYPE_APPEARANCE = const(0x19)
20 | 
21 | 
22 | # Generate a payload to be passed to gap_advertise(adv_data=...).
23 | def advertising_payload(limited_disc=False, br_edr=False, name=None, services=None, appearance=0):
24 |     payload = bytearray()
25 | 
26 |     def _append(adv_type, value):
27 |         nonlocal payload
28 |         payload += struct.pack("BB", len(value) + 1, adv_type) + value
29 | 
30 |     _append(
31 |         _ADV_TYPE_FLAGS,
32 |         struct.pack("B", (0x01 if limited_disc else 0x02) + (0x18 if br_edr else 0x04)),
33 |     )
34 | 
35 |     if name:
36 |         _append(_ADV_TYPE_NAME, name)
37 | 
38 |     if services:
39 |         for uuid in services:
40 |             b = bytes(uuid)
41 |             if len(b) == 2:
42 |                 _append(_ADV_TYPE_UUID16_COMPLETE, b)
43 |             elif len(b) == 4:
44 |                 _append(_ADV_TYPE_UUID32_COMPLETE, b)
45 |             elif len(b) == 16:
46 |                 _append(_ADV_TYPE_UUID128_COMPLETE, b)
47 | 
48 |     # See org.ubluetooth.characteristic.gap.appearance.xml
49 |     if appearance:
50 |         _append(_ADV_TYPE_APPEARANCE, struct.pack("<h", appearance))
51 | 
52 |     return payload
53 | 
54 | 
55 | def decode_field(payload, adv_type):
56 |     i = 0
57 |     result = []
58 |     while i + 1 < len(payload):
59 |         if payload[i + 1] == adv_type:
60 |             result.append(payload[i + 2 : i + payload[i] + 1])
61 |         i += 1 + payload[i]
62 |     return result
63 | 
64 | 
65 | def decode_name(payload):
66 |     n = decode_field(payload, _ADV_TYPE_NAME)
67 |     return str(n[0], "utf-8") if n else ""
68 | 
69 | 
70 | def decode_services(payload):
71 |     services = []
72 |     for u in decode_field(payload, _ADV_TYPE_UUID16_COMPLETE):
73 |         services.append(ubluetooth.UUID(struct.unpack("<h", u)[0]))
74 |     for u in decode_field(payload, _ADV_TYPE_UUID32_COMPLETE):
75 |         services.append(ubluetooth.UUID(struct.unpack("<d", u)[0]))
76 |     for u in decode_field(payload, _ADV_TYPE_UUID128_COMPLETE):
77 |         services.append(ubluetooth.UUID(u))
78 |     return services
79 | 


--------------------------------------------------------------------------------
/src/joystick.py:
--------------------------------------------------------------------------------
 1 | from machine import Pin, ADC
 2 | 
 3 | Ry = ADC(Pin(35))
 4 | Ry.atten(ADC.ATTN_11DB)
 5 | Rx = ADC(Pin(34))
 6 | Rx.atten(ADC.ATTN_11DB)
 7 | button1 = Pin(25, Pin.IN)
 8 | Ly = ADC(Pin(33))
 9 | Ly.atten(ADC.ATTN_11DB)
10 | Lx = ADC(Pin(32))
11 | Lx.atten(ADC.ATTN_11DB)
12 | button2 = Pin(26, Pin.IN)
13 | 
14 | 
15 | def read_values():
16 |     vrx_pos_l = 4095 - Rx.read()
17 |     vry_pos_l = Ry.read()
18 |     swt_val_l = 1 - button1.value()
19 |     vrx_pos_r = Lx.read()
20 |     vry_pos_r = 4095 - Ly.read()
21 |     swt_val_r = 1 - button2.value()
22 |     return ("{}|{}|{}-{}|{}|{}\n".format(vrx_pos_l, vry_pos_l, swt_val_l, vrx_pos_r, vry_pos_r, swt_val_r))
23 | 


--------------------------------------------------------------------------------
/src/joystick_ble.py:
--------------------------------------------------------------------------------
  1 | import joystick
  2 | from time import sleep
  3 | 
  4 | # This example demonstrates a peripheral implementing the Nordic UART Service (NUS).
  5 | 
  6 | import ubluetooth
  7 | from ble_advertising import advertising_payload
  8 | 
  9 | from micropython import const
 10 | 
 11 | _IRQ_CENTRAL_CONNECT = const(1)
 12 | _IRQ_CENTRAL_DISCONNECT = const(2)
 13 | _IRQ_GATTS_WRITE = const(3)
 14 | 
 15 | _UART_UUID = ubluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
 16 | _UART_TX = (
 17 |     ubluetooth.UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E"),
 18 |     ubluetooth.FLAG_NOTIFY,
 19 | )
 20 | _UART_RX = (
 21 |     ubluetooth.UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E"),
 22 |     ubluetooth.FLAG_WRITE,
 23 | )
 24 | _UART_SERVICE = (
 25 |     _UART_UUID,
 26 |     (_UART_TX, _UART_RX),
 27 | )
 28 | 
 29 | # org.bluetooth.characteristic.gap.appearance.xml
 30 | _ADV_APPEARANCE_GENERIC_COMPUTER = const(128)
 31 | 
 32 | 
 33 | class BLEUART:
 34 |     def __init__(self, ble, name="mpy-uart", rxbuf=100):
 35 |         self._ble = ble
 36 |         self._ble.active(True)
 37 |         self._ble.irq(self._irq)
 38 |         ((self._tx_handle, self._rx_handle),) = self._ble.gatts_register_services((_UART_SERVICE,))
 39 |         # Increase the size of the rx buffer and enable append mode.
 40 |         self._ble.gatts_set_buffer(self._rx_handle, rxbuf, True)
 41 |         self._connections = set()
 42 |         self._rx_buffer = bytearray()
 43 |         self._handler = None
 44 |         # Optionally add services=[_UART_UUID], but this is likely to make the payload too large.
 45 |         self._payload = advertising_payload(name=name, appearance=_ADV_APPEARANCE_GENERIC_COMPUTER)
 46 |         self._advertise()
 47 | 
 48 |     def irq(self, handler):
 49 |         self._handler = handler
 50 | 
 51 |     def _irq(self, event, data):
 52 |         # Track connections so we can send notifications.
 53 |         if event == _IRQ_CENTRAL_CONNECT:
 54 |             conn_handle, _, _ = data
 55 |             self._connections.add(conn_handle)
 56 |         elif event == _IRQ_CENTRAL_DISCONNECT:
 57 |             conn_handle, _, _ = data
 58 |             if conn_handle in self._connections:
 59 |                 self._connections.remove(conn_handle)
 60 |             # Start advertising again to allow a new connection.
 61 |             self._advertise()
 62 |         elif event == _IRQ_GATTS_WRITE:
 63 |             conn_handle, value_handle = data
 64 |             if conn_handle in self._connections and value_handle == self._rx_handle:
 65 |                 self._rx_buffer += self._ble.gatts_read(self._rx_handle)
 66 |                 if self._handler:
 67 |                     self._handler()
 68 | 
 69 |     def any(self):
 70 |         return len(self._rx_buffer)
 71 | 
 72 |     def read(self, sz=None):
 73 |         if not sz:
 74 |             sz = len(self._rx_buffer)
 75 |         result = self._rx_buffer[0:sz]
 76 |         self._rx_buffer = self._rx_buffer[sz:]
 77 |         return result
 78 | 
 79 |     def write(self, data):
 80 |         for conn_handle in self._connections:
 81 |             self._ble.gatts_notify(conn_handle, self._tx_handle, data)
 82 | 
 83 |     def close(self):
 84 |         for conn_handle in self._connections:
 85 |             self._ble.gap_disconnect(conn_handle)
 86 |         self._connections.clear()
 87 | 
 88 |     def _advertise(self, interval_us=500000):
 89 |         self._ble.gap_advertise(interval_us, adv_data=self._payload)
 90 | 
 91 | ble = ubluetooth.BLE()
 92 | uart = BLEUART(ble)
 93 | 
 94 | def on_rx():
 95 |     print("rx: ", uart.read().decode().strip())
 96 | 
 97 | uart.irq(handler=on_rx)
 98 | nums = [4, 8, 15, 16, 23, 42]
 99 | i = 0
100 | 
101 | while True:
102 |     str = joystick.read_values()
103 |     print(str)
104 |     uart.write(str)
105 |     sleep(0.1)
106 | 
107 | uart.close()
108 | 


--------------------------------------------------------------------------------
/src/main.py:
--------------------------------------------------------------------------------
1 | # for bluetooth transmission
2 | import joystick_ble
3 | 


--------------------------------------------------------------------------------