Hi,
would someone have a most basic sketch that combines these parts?
Blynk + RedBear Duo + BLE + Particle IDE + Android
a ‘hello world’ sort of speak.
thank-you in advance.
-
RedBear is not yet found in the sketch build:
https://examples.blynk.cc/ -
The Github has a sketch RedBear_Duo_BLE.ino
https://github.com/blynkkk/blynk-library/tree/master/examples/Boards_Bluetooth/RedBear_Duo_BLE
after these steps,
Already in Blynk Library
Blynk/BlynkApi.h
Blynk/BlynkProtocol.h
utility/BlynkUtility.h
Add Library
Arduino
Blynk
Create library .h
BlynkSimpleRedBear_Duo_BLE.h
BlynkApiArduino.h
utility/BlynkFifo2.h
generates error messages when compiling, not familiar with what would be appropriate for this error,
lib/blynk/src/BlynkApiParticle.h:18:6: error: redefinition of 'void BlynkApi<Proto>::Init()'
void BlynkApi<Proto>::Init()
- The RedBear Duo sketch SimpleChat after flash does Connect BLE Device,
https://github.com/redbear/STM32-Arduino/tree/master/arduino/libraries/RedBear_Duo/examples/03.BLE/SimpleChat
But after inserting auth token and Blynk.begin(auth);
#include <blynk.h>
#define BLYNK_PRINT Serial
char auth[] = "aut token";
void setup()
{
Serial.begin(9600);
delay(5000);
Blynk.begin(auth);
}
void loop()
{
Blynk.run();
}
I’m not getting any sort of response from the device on Android when clicking for example button D7.
Can you show us your whole sketch including whatever coding you have for button on D7.
Please format all posted code as shown, so it is properly viewable, thanks.
Also, have you searched this forum for the word RedBear? There might be something useful?
Button D7 is digital, and Duo on wifi activates the device blue light D7 (like blynkblink), and also RGB and notification with no issue using iphone and android, …except on BLE that after connecting by BLE on android, D7 and RGB do not activate on android (ble does not show up on ios to connect).
WiFi
// This #include statement was automatically added by the Particle IDE.
#include <blynk.h>
#define BLYNK_PRINT Serial
// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "auth token";
void setup()
{
// Debug console
Serial.begin(9600);
delay(5000); // Allow board to settle
Blynk.begin(auth);
}
// Attach a Button widget (mode: Push) to the Virtual pin 1 - and send sweet tweets!
BLYNK_WRITE(V1) {
if (param.asInt() == 1) { // On button down...
// Tweeting!
// Note:
// We allow 1 tweet per minute for now.
// Twitter doesn't allow identical subsequent messages.
//Blynk.tweet("My Particle project is tweeting using @blynk_app and it’s awesome!\n @Particle #IoT #blynk");
// Pushing notification to the app!
// Note:
// We allow 1 notification per minute for now.
Blynk.notify("You pressed the button and I know it ;)");
}
}
// Attach a ZeRGBa widget (mode: Merge) to the Virtual pin 2 - and control the built-in RGB led!
BLYNK_WRITE(V2) {
int r = param[0].asInt();
int g = param[1].asInt();
int b = param[2].asInt();
if (r > 0 || g > 0 || b > 0) {
RGB.control(true);
RGB.color(r, g, b);
} else {
RGB.control(false);
}
}
void loop()
{
Blynk.run();
// You can inject your own code or combine it with other sketches.
// Check other examples on how to communicate with Blynk. Remember
// to avoid delay() function!
}
BLE
// This #include statement was automatically added by the Particle IDE.
#include <blynk.h>
/*
* Copyright (c) 2016 RedBear
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
/*
* Download RedBear "BLE Controller" APP from APP store(IOS)/Play Store(Android) to play with this sketch
*/
/******************************************************
* Macros
******************************************************/
/*
* Defaultly disabled. More details: https://docs.particle.io/reference/firmware/photon/#system-thread
*/
//SYSTEM_THREAD(ENABLED);
/*
* Defaultly disabled. If BLE setup is enabled, when the Duo is in the Listening Mode, it will de-initialize and re-initialize the BT stack.
* Then it broadcasts as a BLE peripheral, which enables you to set up the Duo via BLE using the RedBear Duo App or customized
* App by following the BLE setup protocol: https://github.com/redbear/Duo/blob/master/docs/listening_mode_setup_protocol.md#ble-peripheral
*
* NOTE: If enabled and upon/after the Duo enters/leaves the Listening Mode, the BLE functionality in your application will not work properly.
*/
//BLE_SETUP(ENABLED);
/*
* SYSTEM_MODE:
* - AUTOMATIC: Automatically try to connect to Wi-Fi and the Particle Cloud and handle the cloud messages.
* - SEMI_AUTOMATIC: Manually connect to Wi-Fi and the Particle Cloud, but automatically handle the cloud messages.
* - MANUAL: Manually connect to Wi-Fi and the Particle Cloud and handle the cloud messages.
*
* SYSTEM_MODE(AUTOMATIC) does not need to be called, because it is the default state.
* However the user can invoke this method to make the mode explicit.
* Learn more about system modes: https://docs.particle.io/reference/firmware/photon/#system-modes .
*/
#if defined(ARDUINO)
SYSTEM_MODE(SEMI_AUTOMATIC);
#endif
/*
* BLE peripheral preferred connection parameters:
* - Minimum connection interval = MIN_CONN_INTERVAL * 1.25 ms, where MIN_CONN_INTERVAL ranges from 0x0006 to 0x0C80
* - Maximum connection interval = MAX_CONN_INTERVAL * 1.25 ms, where MAX_CONN_INTERVAL ranges from 0x0006 to 0x0C80
* - The SLAVE_LATENCY ranges from 0x0000 to 0x03E8
* - Connection supervision timeout = CONN_SUPERVISION_TIMEOUT * 10 ms, where CONN_SUPERVISION_TIMEOUT ranges from 0x000A to 0x0C80
*/
#define MIN_CONN_INTERVAL 0x0028 // 50ms.
#define MAX_CONN_INTERVAL 0x0190 // 500ms.
#define SLAVE_LATENCY 0x0000 // No slave latency.
#define CONN_SUPERVISION_TIMEOUT 0x03E8 // 10s.
// Learn about appearance: http://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.gap.appearance.xml
#define BLE_PERIPHERAL_APPEARANCE BLE_APPEARANCE_UNKNOWN
#define BLE_DEVICE_NAME "Simple Chat RBS"
#define CHARACTERISTIC1_MAX_LEN 15
#define CHARACTERISTIC2_MAX_LEN 15
#define TXRX_BUF_LEN 15
#define BLYNK_PRINT Serial
char auth[] = "auth token";
/******************************************************
* Variable Definitions
******************************************************/
static uint8_t service1_uuid[16] = { 0x71,0x3d,0x00,0x00,0x50,0x3e,0x4c,0x75,0xba,0x94,0x31,0x48,0xf1,0x8d,0x94,0x1e };
static uint8_t service1_tx_uuid[16] = { 0x71,0x3d,0x00,0x03,0x50,0x3e,0x4c,0x75,0xba,0x94,0x31,0x48,0xf1,0x8d,0x94,0x1e };
static uint8_t service1_rx_uuid[16] = { 0x71,0x3d,0x00,0x02,0x50,0x3e,0x4c,0x75,0xba,0x94,0x31,0x48,0xf1,0x8d,0x94,0x1e };
// GAP and GATT characteristics value
static uint8_t appearance[2] = {
LOW_BYTE(BLE_PERIPHERAL_APPEARANCE),
HIGH_BYTE(BLE_PERIPHERAL_APPEARANCE)
};
static uint8_t change[4] = {
0x00, 0x00, 0xFF, 0xFF
};
static uint8_t conn_param[8] = {
LOW_BYTE(MIN_CONN_INTERVAL), HIGH_BYTE(MIN_CONN_INTERVAL),
LOW_BYTE(MAX_CONN_INTERVAL), HIGH_BYTE(MAX_CONN_INTERVAL),
LOW_BYTE(SLAVE_LATENCY), HIGH_BYTE(SLAVE_LATENCY),
LOW_BYTE(CONN_SUPERVISION_TIMEOUT), HIGH_BYTE(CONN_SUPERVISION_TIMEOUT)
};
/*
* BLE peripheral advertising parameters:
* - advertising_interval_min: [0x0020, 0x4000], default: 0x0800, unit: 0.625 msec
* - advertising_interval_max: [0x0020, 0x4000], default: 0x0800, unit: 0.625 msec
* - advertising_type:
* BLE_GAP_ADV_TYPE_ADV_IND
* BLE_GAP_ADV_TYPE_ADV_DIRECT_IND
* BLE_GAP_ADV_TYPE_ADV_SCAN_IND
* BLE_GAP_ADV_TYPE_ADV_NONCONN_IND
* - own_address_type:
* BLE_GAP_ADDR_TYPE_PUBLIC
* BLE_GAP_ADDR_TYPE_RANDOM
* - advertising_channel_map:
* BLE_GAP_ADV_CHANNEL_MAP_37
* BLE_GAP_ADV_CHANNEL_MAP_38
* BLE_GAP_ADV_CHANNEL_MAP_39
* BLE_GAP_ADV_CHANNEL_MAP_ALL
* - filter policies:
* BLE_GAP_ADV_FP_ANY
* BLE_GAP_ADV_FP_FILTER_SCANREQ
* BLE_GAP_ADV_FP_FILTER_CONNREQ
* BLE_GAP_ADV_FP_FILTER_BOTH
*
* Note: If the advertising_type is set to BLE_GAP_ADV_TYPE_ADV_SCAN_IND or BLE_GAP_ADV_TYPE_ADV_NONCONN_IND,
* the advertising_interval_min and advertising_interval_max should not be set to less than 0x00A0.
*/
static advParams_t adv_params = {
.adv_int_min = 0x0030,
.adv_int_max = 0x0030,
.adv_type = BLE_GAP_ADV_TYPE_ADV_IND,
.dir_addr_type = BLE_GAP_ADDR_TYPE_PUBLIC,
.dir_addr = {0,0,0,0,0,0},
.channel_map = BLE_GAP_ADV_CHANNEL_MAP_ALL,
.filter_policy = BLE_GAP_ADV_FP_ANY
};
static uint8_t adv_data[] = {
0x02,
BLE_GAP_AD_TYPE_FLAGS,
BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE,
0x08,
BLE_GAP_AD_TYPE_SHORT_LOCAL_NAME,
'B','i','s','c','u','i','t',
0x11,
BLE_GAP_AD_TYPE_128BIT_SERVICE_UUID_COMPLETE,
0x1e,0x94,0x8d,0xf1,0x48,0x31,0x94,0xba,0x75,0x4c,0x3e,0x50,0x00,0x00,0x3d,0x71
};
static uint16_t character1_handle = 0x0000;
static uint16_t character2_handle = 0x0000;
static uint8_t characteristic1_data[CHARACTERISTIC1_MAX_LEN] = { 0x01 };
static uint8_t characteristic2_data[CHARACTERISTIC2_MAX_LEN] = { 0x00 };
static btstack_timer_source_t characteristic2;
char rx_buf[TXRX_BUF_LEN];
static uint8_t rx_state = 0;
/******************************************************
* Function Definitions
******************************************************/
void deviceConnectedCallback(BLEStatus_t status, uint16_t handle) {
switch (status) {
case BLE_STATUS_OK:
Serial.println("Device connected!");
break;
default: break;
}
}
void deviceDisconnectedCallback(uint16_t handle){
Serial.println("Disconnected.");
}
int gattWriteCallback(uint16_t value_handle, uint8_t *buffer, uint16_t size) {
Serial.print("Write value handler: ");
Serial.println(value_handle, HEX);
if (character1_handle == value_handle) {
memcpy(characteristic1_data, buffer, min(size,CHARACTERISTIC1_MAX_LEN));
Serial.print("Characteristic1 write value: ");
for (uint8_t index = 0; index < min(size,CHARACTERISTIC1_MAX_LEN); index++) {
Serial.print(characteristic1_data[index], HEX);
Serial.print(" ");
}
Serial.println(" ");
}
return 0;
}
/*void m_uart_rx_handle() { //update characteristic data
ble.sendNotify(character2_handle, rx_buf, CHARACTERISTIC2_MAX_LEN);
memset(rx_buf, 0x00,20);
rx_state = 0;
}*/
static void characteristic2_notify(btstack_timer_source_t *ts) {
if (Serial.available()) {
//read the serial command into a buffer
uint8_t rx_len = min(Serial.available(), CHARACTERISTIC2_MAX_LEN);
Serial.readBytes(rx_buf, rx_len);
//send the serial command to the server
Serial.print("Sent: ");
Serial.println(rx_buf);
rx_state = 1;
}
if (rx_state != 0) {
ble.sendNotify(character2_handle, (uint8_t*)rx_buf, CHARACTERISTIC2_MAX_LEN);
memset(rx_buf, 0x00, 20);
rx_state = 0;
}
// reset
ble.setTimer(ts, 200);
ble.addTimer(ts);
}
void setup() {
Serial.begin(115200);
delay(5000);
Serial.println("Simple Chat demo.");
//ble.debugLogger(true);
// Initialize ble_stack.
ble.init();
// Register BLE callback functions
ble.onConnectedCallback(deviceConnectedCallback);
ble.onDisconnectedCallback(deviceDisconnectedCallback);
ble.onDataWriteCallback(gattWriteCallback);
// Add GAP service and characteristics
ble.addService(BLE_UUID_GAP);
ble.addCharacteristic(BLE_UUID_GAP_CHARACTERISTIC_DEVICE_NAME, ATT_PROPERTY_READ|ATT_PROPERTY_WRITE, (uint8_t*)BLE_DEVICE_NAME, sizeof(BLE_DEVICE_NAME));
ble.addCharacteristic(BLE_UUID_GAP_CHARACTERISTIC_APPEARANCE, ATT_PROPERTY_READ, appearance, sizeof(appearance));
ble.addCharacteristic(BLE_UUID_GAP_CHARACTERISTIC_PPCP, ATT_PROPERTY_READ, conn_param, sizeof(conn_param));
// Add GATT service and characteristics
ble.addService(BLE_UUID_GATT);
ble.addCharacteristic(BLE_UUID_GATT_CHARACTERISTIC_SERVICE_CHANGED, ATT_PROPERTY_INDICATE, change, sizeof(change));
// Add user defined service and characteristics
ble.addService(service1_uuid);
character1_handle = ble.addCharacteristicDynamic(service1_tx_uuid, ATT_PROPERTY_NOTIFY|ATT_PROPERTY_WRITE|ATT_PROPERTY_WRITE_WITHOUT_RESPONSE, characteristic1_data, CHARACTERISTIC1_MAX_LEN);
character2_handle = ble.addCharacteristicDynamic(service1_rx_uuid, ATT_PROPERTY_NOTIFY, characteristic2_data, CHARACTERISTIC2_MAX_LEN);
// Set BLE advertising parameters
ble.setAdvertisementParams(&adv_params);
// // Set BLE advertising data
ble.setAdvertisementData(sizeof(adv_data), adv_data);
// BLE peripheral starts advertising now.
ble.startAdvertising();
Serial.println("BLE start advertising.");
// set one-shot timer
characteristic2.process = &characteristic2_notify;
ble.setTimer(&characteristic2, 500);//100ms
ble.addTimer(&characteristic2);
Blynk.begin(auth);
}
// Attach a Button widget (mode: Push) to the Virtual pin 1 - and send sweet tweets!
BLYNK_WRITE(V1) {
if (param.asInt() == 1) { // On button down...
// Tweeting!
// Note:
// We allow 1 tweet per minute for now.
// Twitter doesn't allow identical subsequent messages.
//Blynk.tweet("My Particle project is tweeting using @blynk_app and it’s awesome!\n @Particle #IoT #blynk");
// Pushing notification to the app!
// Note:
// We allow 1 notification per minute for now.
Blynk.notify("You pressed the button and I know it ;)");
}
}
// Attach a ZeRGBa widget (mode: Merge) to the Virtual pin 2 - and control the built-in RGB led!
BLYNK_WRITE(V2) {
int r = param[0].asInt();
int g = param[1].asInt();
int b = param[2].asInt();
if (r > 0 || g > 0 || b > 0) {
RGB.control(true);
RGB.color(r, g, b);
} else {
RGB.control(false);
}
}
void loop() {
Blynk.run();
}