DroneBridge lib example usage
Examples on how to use DroneBridge library to send & receive custom data
DroneBridge Common library
All DroneBridge modules use the DroneBridge Common library to send & receive data. Below are some examples given on how to use the library. It is available for Python and C/C++. Both implementations are native and not directly linked.
AES encryption 128, 192 or 256-bit is currently only available for the Python implementation. Pycryptodomex is used.
Python
Link to the DroneBridge class. All examples can also be found inside the git repository.
Sending
example_sender.py
#
# This file is part of DroneBridge: https://github.com/seeul8er/DroneBridge
#
# Copyright 2019 Wolfgang Christl
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import time
from DroneBridge import DroneBridge, DBDir, DBMode, DBPort
list_wifi_interfaces = ['wlx00c0ca973410'] # must be in monitor mode
communication_id = 22 # idents a link, multiple systems with same ports on same frequency possible
send_recv_port = DBPort.DB_PORT_GENERIC_1 # Virtual port to which the packet is addressed to
frame_type = 1 # RTS, 2 DATA
compatibility_mode = False # Enable with unpatched Kernels etc. (try without first)
send_direction = DBDir.DB_TO_UAV # Direction of the packet. Reverse direction on receiving side needed
# Set to None for unencrypted link. Must be the same on receiving side.
# length of 32, 48 or 64 characters representing 128bit, 192bit and 256bit AES encryption
encrypt_key = "3373367639792442264528482B4D6251" # bytes or string representing HEX
payload_data = b'HelloEveryone.IamPayload!LifeIsEasyWhenYouArePayload'
dronebridge = DroneBridge(send_direction, list_wifi_interfaces, DBMode.MONITOR, communication_id, send_recv_port,
tag="Test_Sender", db_blocking_socket=True, frame_type=frame_type,
compatibility_mode=compatibility_mode, encryption_key=encrypt_key)
list_sockets_raw = dronebridge.list_lr_sockets # List of raw sockets to be used for manual send/receive operations
for i in range(10000):
time.sleep(0.5)
dronebridge.sendto_uav(payload_data, send_recv_port)
print("\r" + str(i), end='')
print("\nDone sending!")Receiving
example_receiver.py
#
# This file is part of DroneBridge: https://github.com/seeul8er/DroneBridge
#
# Copyright 2019 Wolfgang Christl
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from DroneBridge import DroneBridge, DBDir, DBMode, DBPort
list_wifi_interfaces = ['wlx8416f916382c'] # must be in monitor mode
communication_id = 22
send_recv_port = DBPort.DB_PORT_GENERIC_1
frame_type = 1 # RTS, 2 DATA
compatibility_mode = False
send_direction = DBDir.DB_TO_GND
# Set to None for unencrypted link. Must be the same on receiving side.
# length of 32, 48 or 64 characters representing 128bit, 192bit and 256bit AES encryption
encrypt_key = "3373367639792442264528482B4D6251" # bytes or string representing HEX
dronebridge = DroneBridge(send_direction, list_wifi_interfaces, DBMode.MONITOR, communication_id, send_recv_port,
tag="Test_Receiver", db_blocking_socket=True, frame_type=frame_type,
compatibility_mode=compatibility_mode, encryption_key=encrypt_key)
dronebridge.clear_socket_buffers()
for i in range(100):
received_payload = dronebridge.receive_data()
if received_payload:
print("Received: " + received_payload.decode())
C/C++
The common library must be linked during compilation. An example CMakeLists.txt is given blow. Place the file inside a folder of the root directory of the DroneBridge git project and it should compile right away.
CMakeLists.txt
cmake_minimum_required(VERSION 3.5)
project(example)
set(CMAKE_C_STANDARD 11)
add_subdirectory(../common db_common)
set(SRC_FILES_RECV receive_main.c)
set(SRC_FILES_SEND send_main.c)
add_executable(send ${SRC_FILES_SEND})
target_link_libraries(send db_common)
add_executable(receive ${SRC_FILES_RECV})
target_link_libraries(receive db_common)Sending
send_main.c
/*
* This file is part of DroneBridge: https://github.com/seeul8er/DroneBridge
*
* Copyright 2019 Wolfgang Christl
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include <signal.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include <zconf.h>
#include "../common/db_raw_send_receive.h"
// DroneBridge options
#define INTERFACE "wlx8416f916382c"
#define FRAME_TYPE 2 // 1=RTS; 2=DATA
#define DATARATE 11 // Mbit
#define COMMID 16
#define DST_PORT 10 // destination port
#define RECV_PORT DST_PORT
#define PAYLOAD_BUFF_SIZ 1024
int keep_running = 1;
void int_handler(int dummy) {
keep_running = 0;
}
int main(int argc, char *argv[]) {
signal(SIGINT, int_handler);
signal(SIGTERM, int_handler);
char interface[IFNAMSIZ];
strcpy(interface, INTERFACE);
db_socket_t raw_socket = open_db_socket(interface, COMMID, 'm', DATARATE, DB_DIREC_GROUND,
RECV_PORT, (uint8_t) FRAME_TYPE);
uint8_t seq_num = 0;
uint8_t payload[PAYLOAD_BUFF_SIZ];
memset(payload, 1, PAYLOAD_BUFF_SIZ);
while(keep_running) {
db_send_div(&raw_socket, payload, DST_PORT, PAYLOAD_BUFF_SIZ, update_seq_num(&seq_num), 0);
printf(".");
fflush(stdout);
usleep((unsigned int) 1e6);
}
close(raw_socket.db_socket);
printf("Terminated");
}Receiving
receive_main.c
/*
* This file is part of DroneBridge: https://github.com/seeul8er/DroneBridge
*
* Copyright 2019 Wolfgang Christl
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
/**
* Example on how to use DroneBridge common library to receive data.
* This example receives on the port of the status module.
* Set port & adapter name to match your configuration
*/
#include <string.h>
#include <stdio.h>
#include <signal.h>
#include <zconf.h>
#include "../common/db_raw_send_receive.h"
#include "../common/db_raw_receive.h"
#define BUFFER_SIZE 2048
#define ADAPTER_NAME "wlx8416f916382c" // Name of WiFi adapter. Must be in monitor mode
#define DB_RECEIVING_PORT DB_PORT_STATUS // Receive data on DB raw port for status module
#define DB_SEND_DIRECTION DB_DIREC_DRONE // Send data in direction of UAV
int keep_going = 1;
void sig_handler(int sig) {
printf("DroneBridge example receiver: Terminating...\n");
keep_going = 0;
}
int main(int argc, char *argv[]) {
uint8_t buffer[BUFFER_SIZE];
uint8_t payload_buff[DATA_UNI_LENGTH];
uint8_t seq_num = 0;
memset(buffer, 0, BUFFER_SIZE);
uint8_t comm_id = 200;
char db_mode = 'm';
char adapters[DB_MAX_ADAPTERS][IFNAMSIZ];
strncpy(adapters[0], ADAPTER_NAME, IFNAMSIZ);
// init DroneBridge sockets for raw protocol
db_socket_t raw_interfaces[DB_MAX_ADAPTERS]; // array of DroneBridge sockets
memset(raw_interfaces, 0, DB_MAX_ADAPTERS);
raw_interfaces[0] = open_db_socket(adapters[0], comm_id, db_mode, 6, DB_SEND_DIRECTION,
DB_RECEIVING_PORT, DB_FRAMETYPE_DEFAULT);
// Some stuff for proper termination
struct sigaction action;
memset(&action, 0, sizeof(struct sigaction));
action.sa_handler = sig_handler;
sigaction(SIGTERM, &action, NULL);
sigaction(SIGINT, &action, NULL);
printf("DroneBridge example receiver: Waiting for data\n");
while (keep_going) {
uint16_t radiotap_length = 0;
ssize_t received_bytes = recv(raw_interfaces[0].db_socket, buffer, BUFFER_SIZE, 0);
uint16_t payload_length = get_db_payload(buffer, received_bytes, payload_buff, &seq_num, &radiotap_length);
printf("Received raw frame with %zi bytes & %i bytes of payload\n", received_bytes, payload_length);
}
for (int i = 0; i < DB_MAX_ADAPTERS; i++)
close(raw_interfaces[i].db_socket);
return 0;
}
Last updated