Stufin
Home Quick Cart Profile

Bluetooth 5.0 Dual Mode BLE (Feasycom)

Buy Now

Component Name

Bluetooth 5.0 Dual Mode BLE (Feasycom)

Overview

The Bluetooth 5.0 Dual Mode BLE module from Feasycom is a compact, low-power wireless communication module that supports both Bluetooth Basic Rate (BR) and Bluetooth Low Energy (BLE) modes. This module is designed for use in a wide range of Internet of Things (IoT) applications, including wireless sensors, smart home devices, and industrial automation systems.

Functionality

  • Bluetooth Basic Rate (BR) Mode: This mode allows the module to communicate with other BR-enabled devices, such as smartphones, laptops, and tablets, using the Bluetooth protocol.
  • Bluetooth Low Energy (BLE) Mode: This mode enables low-power communication with BLE-enabled devices, making it suitable for battery-powered devices and applications that require low power consumption.
The Bluetooth 5.0 Dual Mode BLE module is capable of operating in two modes

Key Features

  • Bluetooth 5.0 Compliance: The module is compliant with the Bluetooth 5.0 specification, ensuring compatibility with the latest Bluetooth devices and applications.
  • Dual Mode Operation: The module can operate in both BR and BLE modes, allowing it to communicate with a wide range of devices and applications.
  • Low Power Consumption: The module has a low power consumption of 3.3mA in BLE mode, making it suitable for battery-powered devices.
  • High-Speed Data Transfer: The module supports high-speed data transfer rates of up to 2Mbps in BR mode.
  • Long-Range Communication: The module has a maximum transmission power of 8dBm, allowing it to achieve a range of up to 200 meters in BLE mode.
  • Support for Multiple Roles: The module can operate as both a master and slave device, allowing it to participate in multiple roles in a Bluetooth network.
  • Security: The module supports advanced security features, including encryption, secure pairing, and secure data transfer.
  • Small Form Factor: The module has a compact size of 12.5mm x 15mm, making it suitable for use in small form factor devices.
  • Easy Integration: The module has a simple and intuitive interface, making it easy to integrate into custom designs and applications.

Frequency

2.4GHz

Transmission Power

Up to 8dBm

Receiver Sensitivity

-90dBm

Power Consumption

3.3mA (BLE mode), 20mA (BR mode)

Operating Voltage

1.8V - 3.6V

Operating Temperature

-40C to 85C

Storage Temperature

-40C to 150C

-certificationsFCC, CE, TELEC, IC, and SRRC compliant

Applications

The Bluetooth 5.0 Dual Mode BLE module is suitable for use in a wide range of IoT applications, including

Wireless sensors and monitoring systems

Smart home devices and automation systems

Industrial automation and control systems

Wearable devices and accessories

Healthcare and medical devices

Consumer electronics and appliances

Pin Configuration

  • Bluetooth 5.0 Dual Mode BLE (Feasycom) Module Pinout Explanation
  • The Bluetooth 5.0 Dual Mode BLE (Feasycom) module is a compact, low-power wireless communication module that supports both Bluetooth Low Energy (BLE) and Bluetooth Basic Rate (BR) modes. This document provides a detailed explanation of the module's pins and their functions.
  • Pinout Structure:
  • The Bluetooth 5.0 Dual Mode BLE (Feasycom) module has a total of 24 pins, arranged in a 2x12-pin layout. The pins are divided into power supply pins, interface pins, and control pins.
  • Pin Description:
  • Here's a point-by-point explanation of each pin:
  • Power Supply Pins:
  • 1. VCC (Pin 1): Supply voltage input (1.8V to 3.6V)
  • 2. GND (Pin 2): Ground connection
  • Interface Pins:
  • 3. RXD (Pin 3): UART receive data input
  • 4. TXD (Pin 4): UART transmit data output
  • 5. CTS (Pin 5): UART clear-to-send input (optional)
  • 6. RTS (Pin 6): UART request-to-send output (optional)
  • Control Pins:
  • 7. RESET (Pin 7): Active-low reset input (minimum pulse width: 10ns)
  • 8. WAKEUP (Pin 8): Active-low wakeup input (wake-up from sleep mode)
  • GPIO Pins:
  • 9. GPIO0 (Pin 9): General-purpose I/O pin (configurable as input or output)
  • 10. GPIO1 (Pin 10): General-purpose I/O pin (configurable as input or output)
  • 11. GPIO2 (Pin 11): General-purpose I/O pin (configurable as input or output)
  • 12. GPIO3 (Pin 12): General-purpose I/O pin (configurable as input or output)
  • Analog Pins:
  • 13. ADC_IN (Pin 13): Analog-to-digital converter input (optional)
  • Debug Pins:
  • 14. _Debug_TX (Pin 14): Debug UART transmit data output (optional)
  • 15. _Debug_RX (Pin 15): Debug UART receive data input (optional)
  • NC Pins:
  • 16. NC (Pin 16): No connection (reserved for future use)
  • 17. NC (Pin 17): No connection (reserved for future use)
  • 18. NC (Pin 18): No connection (reserved for future use)
  • 19. NC (Pin 19): No connection (reserved for future use)
  • 20. NC (Pin 20): No connection (reserved for future use)
  • Antenna Pins:
  • 21. ANT (Pin 21): Antenna connection (50 impedance)
  • 22. ANT_GND (Pin 22): Antenna ground connection
  • Shield Pins:
  • 23. SHIELD (Pin 23): Shielding connection (optional)
  • 24. SHIELD_GND (Pin 24): Shielding ground connection (optional)
  • Connecting the Pins:
  • When connecting the pins, ensure that the module is powered from a stable 1.8V to 3.6V supply voltage. Connect the RXD pin to the TX pin of your microcontroller, and the TXD pin to the RX pin of your microcontroller. The CTS and RTS pins can be connected if your microcontroller requires hardware flow control.
  • The RESET pin should be connected to a 10k pull-up resistor to VCC, and the WAKEUP pin can be connected to a 10k pull-up resistor to VCC or left unconnected if not used.
  • The GPIO pins can be configured as inputs or outputs depending on your application requirements. The ADC_IN pin can be connected to an analog signal source if the module is configured to use the ADC feature.
  • The debug pins (_Debug_TX and _Debug_RX) can be connected to a serial console or a debug tool for debugging purposes.
  • The NC pins should be left unconnected. The ANT and ANT_GND pins should be connected to a suitable antenna for wireless communication.
  • The SHIELD and SHIELD_GND pins can be connected to a metal shield or a ground plane for EMI shielding, but this is optional.
  • Remember to handle the module with care, as it is a sensitive electronic component. Always follow proper soldering and assembly procedures to ensure reliable operation.

Code Examples

Bluetooth 5.0 Dual Mode BLE (Feasycom) Component Documentation
Overview
The Bluetooth 5.0 Dual Mode BLE (Feasycom) component is a high-performance, low-power Bluetooth module that supports both Bluetooth Low Energy (BLE) and Bluetooth Basic Rate (BR) modes. This module is ideal for IoT applications that require wireless communication, proximity sensing, and low-power consumption.
Technical Specifications
Bluetooth Version: 5.0
 Operating Frequency: 2.4 GHz
 Transmission Power: Up to 8 dBm
 Reception Sensitivity: -90 dBm
 Data Transfer Rate: Up to 2 Mbps
 Range: Up to 100 meters (328 feet)
 Power Consumption: 3.3V - 5.5V, 100 mA (peak), 20 A (sleep)
Hardware Interfaces
UART (TX, RX, RTS, CTS)
 SPI (SCK, MOSI, MISO, CS)
 I2C (SCL, SDA)
 GPIO (for external components and sensors)
Software Support
Arduino IDE
 Raspberry Pi (Raspbian OS)
 ESP32/ESP8266 (MicroPython)
 Other platforms (contact manufacturer for compatibility)
Code Examples
### Example 1: Arduino UART Connection (BLE Mode)
Hardware Requirements
Arduino Board (e.g., Arduino Uno)
 Bluetooth 5.0 Dual Mode BLE (Feasycom) module
 Breadboard and jumper wires
Software Requirements
Arduino IDE (version 1.8.10 or higher)
Code
```c
#include <SoftwareSerial.h>
#define BLE_UART_RX 2
#define BLE_UART_TX 3
SoftwareSerial bleSerial(BLE_UART_RX, BLE_UART_TX);
void setup() {
  Serial.begin(115200);
  bleSerial.begin(9600);
}
void loop() {
  bleSerial.println("AT+BLESTART");
  delay(100);
  bleSerial.println("AT+GATTADD=0x180F");
  delay(100);
  bleSerial.println("AT+GATTCHAR=0x2902,0x2903");
  delay(100);
  
  // Scan for nearby devices
  bleSerial.println("AT+ Scan");
  delay(5000);
  
  // Connect to a device
  bleSerial.println("AT+CONNECT=<device_address>");
  delay(500);
  
  // Send data to the connected device
  bleSerial.println("AT+SEND=<data>");
  delay(100);
  
  // Disconnect from the device
  bleSerial.println("AT+DISCONNECT");
  delay(500);
}
```
### Example 2: Raspberry Pi Python Script (BR Mode)
Hardware Requirements
Raspberry Pi (e.g., Raspberry Pi 4)
 Bluetooth 5.0 Dual Mode BLE (Feasycom) module
 Breadboard and jumper wires
Software Requirements
Raspbian OS (version 10 or higher)
 Python 3.x
Code
```python
import bluetooth
# Initialize the Bluetooth module
bt_module = bluetooth.BluetoothDevice(0x00, 0x1A, 0x7D, 0x00, 0x06, 0x95)
# Set the module to BR mode
bt_module.set_mode(bluetooth.MODE_BR)
# Scan for nearby devices
devices = bt_module.discover_devices(lookup_names=True, duration=5)
print("Found {} devices.".format(len(devices)))
# Connect to a device
device_address = devices[0][0]
bt_module.connect(device_address)
# Send data to the connected device
bt_module.send_data("Hello, Raspberry Pi!")
# Disconnect from the device
bt_module.disconnect(device_address)
```
### Example 3: ESP32 MicroPython (BLE Mode with Sensors)
Hardware Requirements
ESP32 Board (e.g., ESP32 DevKitC)
 Bluetooth 5.0 Dual Mode BLE (Feasycom) module
 Breadboard and jumper wires
 Sensors (e.g., temperature, humidity)
Software Requirements
MicroPython (version 1.12 or higher)
Code
```python
import machine
import esp32
import bluetooth
# Initialize the Bluetooth module
bt_module = bluetooth.BLE()
# Initialize the sensors
temp_sensor = machine.ADC(machine.Pin(32))
humidity_sensor = machine.ADC(machine.Pin(33))
# Set the module to BLE mode
bt_module.set_mode(bluetooth.MODE_BLE)
# Define a function to read sensor data
def read_sensors():
  temp_value = temp_sensor.read()
  humidity_value = humidity_sensor.read()
  return temp_value, humidity_value
# Define a function to send sensor data
def send_data(temp_value, humidity_value):
  bt_module.start_adv()
  bt_module.send_data("Temperature: {}C, Humidity: {}%".format(temp_value, humidity_value))
  bt_module.stop_adv()
while True:
  temp_value, humidity_value = read_sensors()
  send_data(temp_value, humidity_value)
  machine.sleep(1000)
```
Note: These code examples are for demonstration purposes only and may require modifications to adapt to your specific use case. Consult the manufacturer's documentation for detailed instructions and specifications.