int main(int argc, char **argv)
{
struct sockaddr_rc addr = { 0 };
int s, status;
char dest[18] = "";
strcpy(dest,argv[1]); //take first argument as server address
// allocate a socket
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
printf("%d",s);
// set the connection parameters (who to connect to)
addr.rc_family = AF_BLUETOOTH;
addr.rc_channel = (uint8_t) 1;
str2ba( dest, &addr.rc_bdaddr );
// connect to server
status = connect(s, (struct sockaddr *)&addr, sizeof(addr));
// send a message
if( status == 0 ) {
int a = 0;
for(a=2;a<argc;a++){
send(s, argv[a], strlen(argv[a]),0);
}
send(s, SIGNAL_FINISH, strlen(SIGNAL_FINISH),0);
}
if( status < 0 ){
perror(dest);
}
close(s);
return 0;
}
static int getbdaddrbyname(char *str, bdaddr_t *ba)
{
int i, n, len;
len = strlen(str);
/* Check address format */
for (i = 0, n = 0; i < len; i++)
if (str[i] == ':')
n++;
if (n == 5) {
/* BD address */
str2ba(str, ba);
return 0;
}
if (n == 0) {
/* loopback port */
in_addr_t addr = INADDR_LOOPBACK;
uint16_t be16 = htons(atoi(str));
bdaddr_t b;
memcpy(&b, &addr, 4);
memcpy(&b.b[4], &be16, sizeof(be16));
baswap(ba, &b);
return 0;
}
fprintf(stderr, "Invalid address format\n");
return -1;
}
int devname(char *pAddress, char *pName, int sz )
{
bdaddr_t bdaddr;
//char name[248]
int dd;
str2ba( pAddress, &bdaddr );
int dev_id;
dev_id = hci_get_route( &bdaddr );
if ( dev_id < 0 ) {
printf("Device not available\n");
return -1;
}
dd = hci_open_dev(dev_id);
if (dd < 0) {
printf("HCI device open failed\n");
return -2;
}
if ( hci_read_remote_name( dd,
&bdaddr,
sz,
pName,
25000) != 0) {
close(dd);
printf("Could not find device %s\n", pAddress);
return -3;
}
close(dd);
return 0;
}
int main(int argc, char **argv)
{
if(argc < 2) {
printf("Please provide a valid address!\n");
return 1;
}
struct sockaddr_rc addr = { 0 };
int s, status;
char *dest = argv[1];
// allocate a socket
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
// set the connection parameters (who to connect to)
addr.rc_family = AF_BLUETOOTH;
addr.rc_channel = (uint8_t) 1;
str2ba( dest, &addr.rc_bdaddr );
// connect to server
status = connect(s, (struct sockaddr *)&addr, sizeof(addr));
// send a message
if( status == 0 ) {
status = write(s, "hello!", 6);
}
if( status < 0 ) perror("uh oh");
close(s);
return 0;
}
int main(int argc, char **argv)
{
struct sockaddr_rc addr = { 0 };
int s, status;
char dest[18] = "AC:F7:F3:53:31:BE";
char buf[256] = {0};
// allocate a socket
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
// set the connection parameters (who to connect to)
addr.rc_family = AF_BLUETOOTH;
addr.rc_channel = (uint8_t) 2;
str2ba( dest, &addr.rc_bdaddr );
// connect to server
status = connect(s, (struct sockaddr *)&addr, sizeof(addr));
// send a message
if( status == 0 ) {
write(s, "hello!", 6);
read(s, buf, sizeof(buf));
printf("Received: %s",buf);
}
if( status < 0 )
perror("uh oh");
close(s);
return 0;
}
static DBusMessage *add_remote_data(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct btd_adapter *adapter = data;
uint8_t *hash, *randomizer;
int32_t hlen, rlen;
const char *addr;
bdaddr_t bdaddr;
if (!dbus_message_get_args(msg, NULL,
DBUS_TYPE_STRING, &addr,
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &hash, &hlen,
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &randomizer, &rlen,
DBUS_TYPE_INVALID))
return btd_error_invalid_args(msg);
if (hlen != 16 || rlen != 16 || bachk(addr))
return btd_error_invalid_args(msg);
str2ba(addr, &bdaddr);
if (btd_adapter_add_remote_oob_data(adapter, &bdaddr, hash, randomizer))
return btd_error_failed(msg, "Request failed");
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
DBusHandlerResult cancel_authorize_request(DBusConnection *conn,
DBusMessage *msg,
struct service *service,
const char *address,
const char *path)
{
char adapter_path[PATH_MAX];
int adapter_id;
bdaddr_t bdaddr;
if (!default_auth_agent)
return error_auth_agent_does_not_exist(conn, msg);
str2ba(address, &bdaddr);
adapter_id = hci_for_each_dev(HCI_UP, find_conn, (long) &bdaddr);
if (adapter_id < 0)
return error_not_connected(conn, msg);
snprintf(adapter_path, sizeof(adapter_path), "/org/bluez/hci%d",
adapter_id);
return auth_agent_send_cancel(msg, default_auth_agent, adapter_path,
service, address, path);
}
int main(int argc, char **argv)
{
struct sockaddr_rc addr = { 0 };
int s, status;
char dest[18] = "01:23:45:67:89:AB";
// allocate a socket
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
// set the connection parameters (who to connect to)
addr.rc_family = AF_BLUETOOTH;
addr.rc_channel = (uint8_t) 1;
str2ba( dest, &addr.rc_bdaddr );
// connect to server
status = connect(s, (struct sockaddr *)&addr, sizeof(addr));
// send a message
if( status == 0 ) {
status = write(s, "hello!", 6);
}
if( status < 0 ) perror("uh oh");
close(s);
return 0;
}
bool BtPCModul ::GetDeviceInfo(NXTclass *nxtclass)
{
BLUETOOTH_DEVICE_INFO m_device_info = {sizeof(BLUETOOTH_DEVICE_INFO),str2ba(nxtclass->BTaddr),};
if (ERROR_SUCCESS!=BluetoothGetDeviceInfo(m_radio,&m_device_info))
{
printf(" !!!ERROR Get Params\n"); //) {cout<<"Not_Search_Device"<<endl; return 0;}
nxtclass->authenticated=0;
return 0;
}
else
{
wprintf(L" \tInstance Name: %s\r\n", m_device_info.szName);
wprintf(L" \tAddress: %02X:%02X:%02X:%02X:%02X:%02X\r\n",
m_device_info.Address.rgBytes[5],m_device_info.Address.rgBytes[4], m_device_info.Address.rgBytes[3],
m_device_info.Address.rgBytes[2],m_device_info.Address.rgBytes[1], m_device_info.Address.rgBytes[0]);
wprintf(L" \tClass: 0x%08x\r\n", m_device_info.ulClassofDevice);
wprintf(L" \tConnected: %s\r\n", m_device_info.fConnected ? L"true" : L"false");
wprintf(L" \tAuthenticated: %s\r\n", m_device_info.fAuthenticated ? L"true" : L"false");
wprintf(L" \tRemembered: %s\r\n", m_device_info.fRemembered ? L"true" : L"false");
// cout<<" \tCOM-port: "<<nxtclass->port<<"\r\n";
}
nxtclass->authenticated=((m_device_info.fAuthenticated)&&(m_device_info.fRemembered));
for(int i=0; i<BLUETOOTH_MAX_SIZE_NAME; i++)
nxtclass->Name[i]=m_device_info.szName[i];
return 1;
}
int prtL2CAP::connect()
{
sock1 = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_L2CAP);
if (sock1 < 0)
{
printf("[-] prtL2CAP::connect1, socket() failed\n");
return -1;
}
memset(&addr, 0, sizeof(addr));
addr.l2_family = AF_BLUETOOTH;
if (bind(sock1, (struct sockaddr*)&addr, sizeof(addr)) < 0)
{
printf("[-] prtL2CAP:connect1, bind() failed\n");
close(sock1);
sock1 = 0;
return -1;
}
str2ba(((bProfile*)(this->pProfile))->szbtaddr, &addr.l2_bdaddr);
if (::connect(sock1, (struct sockaddr*)&addr, sizeof(addr)) < 0)
{
printf("[-] prtL2CAP::connect1, connect() failed\n");
close(sock1);
sock1 = 0;
return -1;
}
return 0;
}
//GPS Connect
gboolean gps_connect(struct Gps *gps)
{
struct sockaddr_rc gpsaddr_struct = {0};
int status;
//allocate a socket (소켓 생성)
gps->sockfd = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
if(gps->sockfd < 0) {
g_printf("socket error\n");
return FALSE;
} else g_printf("socket success\n");
//sockaddr_rc 구조체 초기화
bzero(&gpsaddr_struct, sizeof(struct sockaddr_rc));
//set the connection parameters (sockaddr_rc 구조체 설정)
gpsaddr_struct.rc_family = AF_BLUETOOTH;
gpsaddr_struct.rc_channel = (uint8_t)atoi(gps->conn_info.gpsport);
str2ba(gps->conn_info.gpsaddr, &gpsaddr_struct.rc_bdaddr);
//connect to server (GPS에 접속)
status = connect(gps->sockfd, (struct sockaddr *)&gpsaddr_struct, sizeof(struct sockaddr_rc));
if(status < 0) {
g_printf("connect error\n");
return FALSE;
} else g_printf("connect success\n");
return TRUE;
}
BdAddr::BdAddr( const char* addr )
{
bdaddr_t a;
str2ba(addr,&a);
memcpy(_baddr, a.b, 6);
}
int write_bdaddr(struct ar3k_config_info *pConfig,u8 *bdaddr,int type)
{
u8 bdaddr_cmd[] = { 0x0B, 0xFC, 0x0A, 0x01, 0x01,
0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
u8 *event;
u8 *bufferToFree = NULL;
int result = A_ERROR;
int inc,outc;
if (type == BDADDR_TYPE_STRING)
str2ba(bdaddr,&bdaddr_cmd[7]);
else {
/* Bdaddr has to be sent as LAP first */
for(inc = 5 ,outc = 7; inc >=0; inc--, outc++)
bdaddr_cmd[outc] = bdaddr[inc];
}
if(0 == SendHCICommandWaitCommandComplete(pConfig,bdaddr_cmd,
sizeof(bdaddr_cmd),
&event,&bufferToFree)) {
if(event[4] == 0xFC && event[5] == 0x00){
if(event[3] == 0x0B){
result = 0;
}
}
}
if(bufferToFree != NULL) {
kfree(bufferToFree);
}
return result;
}
static DBusMessage *disconnect_device(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessage *reply;
struct network_server *ns = data;
struct network_session *session;
const char *addr, *devname;
bdaddr_t dst_addr;
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &addr,
DBUS_TYPE_STRING, &devname,
DBUS_TYPE_INVALID))
return NULL;
str2ba(addr, &dst_addr);
session = find_session_by_addr(ns->sessions, dst_addr);
if (!session)
return btd_error_failed(msg, "No active session");
if (session->io) {
bnep_if_down(devname);
bnep_kill_connection(&dst_addr);
} else
return btd_error_not_connected(msg);
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
return reply;
}
int bt_disconnect(char bdaddr[18])
{
int err = 0, dd;
struct hci_conn_info_req *cr = 0;
// find the connection handle to the specified bluetooth device
cr = (struct hci_conn_info_req*) malloc(
sizeof(struct hci_conn_info_req) + sizeof(struct hci_conn_info));
str2ba(bdaddr, &cr->bdaddr);
cr->type = ACL_LINK;
dd = hci_open_dev(hci_get_route(&cr->bdaddr));
if (dd < 0)
{
err = dd;
goto cleanup;
}
err = ioctl(dd, HCIGETCONNINFO, (unsigned long) cr);
if (err)
goto cleanup;
hci_disconnect(dd, cr->conn_info->handle, HCI_OE_USER_ENDED_CONNECTION, HCI_REQ_TIMEOUT);
cleanup: free(cr);
if (dd >= 0)
close(dd);
return err;
}
int main(int argc, char *argv[])
{
unsigned long flags = DUMP_VERBOSE;
unsigned long filter = ~0L;
bdaddr_t address;
int defpsm = 0;
int defcompid = DEFAULT_COMPID;
int opt, pppdump_fd = -1, audio_fd = -1;
printf("Csr Bluez Coex Sniffer\n");
while ((opt=getopt_long(argc, argv, "a:i:", NULL, NULL)) != -1) {
switch(opt) {
case 'a':
printf("Address = %s\n", optarg);
str2ba(optarg, &address);
break;
case 'h':
default:
usage();
exit(0);
}
}
init_parser(flags, filter, defpsm, defcompid, pppdump_fd, audio_fd);
process_frames(address, flags);
return 0;
}
A_STATUS write_bdaddr(AR3K_CONFIG_INFO *pConfig,A_UCHAR *bdaddr)
{
A_UCHAR bdaddr_cmd[] = { 0x0B, 0xFC, 0x0A, 0x01, 0x01,
0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
A_UINT8 *event;
A_UINT8 *bufferToFree = NULL;
A_STATUS result = A_ERROR;
str2ba(bdaddr,&bdaddr_cmd[7]);
if(A_OK == SendHCICommandWaitCommandComplete(pConfig,bdaddr_cmd,
sizeof(bdaddr_cmd),
&event,&bufferToFree)) {
if(event[4] == 0xFC && event[5] == 0x00){
if(event[3] == 0x0B){
result = A_OK;
}
}
}
if(bufferToFree != NULL) {
A_FREE(bufferToFree);
}
return result;
}
/* Basicly this just sets up standard control bits */
void CWiiRemote::SetBluetoothAddress(const char *btaddr)
{
if (btaddr != NULL)
str2ba(btaddr, &m_btaddr);
else
bacpy(&m_btaddr, &(*BDADDR_ANY));
}
A_STATUS write_bdaddr(AR3K_CONFIG_INFO *pConfig,A_UCHAR *bdaddr,int type)
{
A_UCHAR bdaddr_cmd[] = { 0x0B, 0xFC, 0x0A, 0x01, 0x01,
0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
A_UINT8 *event;
A_UINT8 *bufferToFree = NULL;
A_STATUS result = A_ERROR;
int inc,outc;
if (type == BDADDR_TYPE_STRING)
str2ba(bdaddr,&bdaddr_cmd[7]);
else {
/* Bdaddr has to be sent as LAP first */
for(inc = 5 ,outc = 7; inc >=0; inc--, outc++)
bdaddr_cmd[outc] = bdaddr[inc];
}
if(A_OK == SendHCICommandWaitCommandComplete(pConfig,bdaddr_cmd,
sizeof(bdaddr_cmd),
&event,&bufferToFree)) {
if(event[4] == 0xFC && event[5] == 0x00){
if(event[3] == 0x0B){
result = A_OK;
}
}
}
if(bufferToFree != NULL) {
A_FREE(bufferToFree);
}
return result;
}
/* Basicly this just sets up standard control bits */
void CWiiRemote::SetBluetoothAddress(const char *btaddr)
{
static const bdaddr_t b = {{0, 0, 0, 0, 0, 0}}; /* BDADDR_ANY */
if (btaddr != NULL)
str2ba(btaddr, &m_btaddr);
else
bacpy(&m_btaddr, &b);
}
static int do_connect(char *svr)
{
struct sockaddr_sco addr;
struct sco_conninfo conn;
socklen_t optlen;
int sk;
/* Create socket */
sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO);
if (sk < 0) {
syslog(LOG_ERR, "Can't create socket: %s (%d)",
strerror(errno), errno);
return -1;
}
/* Bind to local address */
memset(&addr, 0, sizeof(addr));
addr.sco_family = AF_BLUETOOTH;
bacpy(&addr.sco_bdaddr, &bdaddr);
if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
syslog(LOG_ERR, "Can't bind socket: %s (%d)",
strerror(errno), errno);
goto error;
}
/* Connect to remote device */
memset(&addr, 0, sizeof(addr));
addr.sco_family = AF_BLUETOOTH;
addr.sco_pkt_type = pkt_type;
str2ba(svr, &addr.sco_bdaddr);
if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
syslog(LOG_ERR, "Can't connect: %s (%d)",
strerror(errno), errno);
goto error;
}
/* Get connection information */
memset(&conn, 0, sizeof(conn));
optlen = sizeof(conn);
if (getsockopt(sk, SOL_SCO, SCO_CONNINFO, &conn, &optlen) < 0) {
syslog(LOG_ERR, "Can't get SCO connection information: %s (%d)",
strerror(errno), errno);
goto error;
}
syslog(LOG_INFO, "Connected [handle %d, class 0x%02x%02x%02x]",
conn.hci_handle,
conn.dev_class[2], conn.dev_class[1], conn.dev_class[0]);
return sk;
error:
close(sk);
return -1;
}
static void do_kill(char *dst)
{
if (dst) {
bdaddr_t ba;
str2ba(dst, &ba);
dun_kill_connection((void *) &ba);
} else
dun_kill_all_connections();
}
int main(int argc, char** argv)
{
// Add BLE address here
char BLEDestinationAddress[18] = "C5:2A:45:36:E3:A2";
// Allocate a socket (from btio/btio.c: line 1532)
int fileDescriptor = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
if (fileDescriptor < 0)
{
ExitOnError(__FUNCTION__, "socket", errno, __FILE__, __LINE__);
}
printf("File Descriptor = %d\n");
// Set connection parameters (from btio/btio.c: l2cap_connect line 346)
struct sockaddr_l2 SocketAddr = { 0 };
str2ba(BLEDestinationAddress, &SocketAddr.l2_bdaddr);
SocketAddr.l2_bdaddr_type = BDADDR_LE_RANDOM;
SocketAddr.l2_family = AF_BLUETOOTH;
SocketAddr.l2_cid = htobs(ATT_CID);
// Connect to server (from btio/btio.c: line 362)
printf("Connecting...\n");
int status = connect(fileDescriptor, (struct sockaddr*)&SocketAddr, sizeof(SocketAddr));
if (status < 0)
{
close(fileDescriptor);
ExitOnError(__FUNCTION__, "connect", errno, __FILE__, __LINE__);
}
else
{
printf("Connected\n");
}
// Test.. compile pas voir README.md reverse engineering #### char-read-uuid ####
//epoll_ctl(epoll_fd, EPOLL_CTL_MOD, data->fd, &ev);
// Send a message
status = write(fileDescriptor, "hello!", 6);
if( status < 0 )
{
close(fileDescriptor);
ExitOnError(__FUNCTION__, "write", errno, __FILE__, __LINE__);
}
else
{
printf("write ok \n");
}
close(fileDescriptor);
return 0;
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "Sphero_Command");
ros::NodeHandle n;
ros::Rate r(1); //update @ 1hz
ros::Subscriber flag_sub = n.subscribe("/sphero_stop_flag", 1, msg_cb_stop_flag); //flag for stop
ros::Subscriber velocity_sub = n.subscribe("/joy", 1, msg_cb_joy); //**** change this line to use different message inputs
struct sockaddr_rc addr = { 0 };
int s, status;
ROS_INFO("Starting Sphero Command...");
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); // allocate a socket
addr.rc_family = AF_BLUETOOTH;
addr.rc_channel = (uint8_t) 1;
str2ba(dest, &addr.rc_bdaddr ); // set the connection parameters (who to connect to)
status = connect(s, (struct sockaddr *)&addr, sizeof(addr)); // connect to server
//create the messages to be used
create_color_message(255,0,0,1,PKT_red);
create_color_message(0,255,0,1,PKT_blue);
create_color_message(250,250,210,1,PKT_yellow);
create_backled_message(255,PKT_backled);
//create_velocity_message(255,0,PKT_vel);
create_velocity_message(0,0,PKT_stop);
//create_boost_message(255,5,PKT_boost);
//create_heading_message(180,PKT_head);
//the_time=(double)ros::Time::now().toSec();
if( status == 0 && ros::ok()) //if socket is open and ros lives
{
ROS_INFO("Testing Sphero with colors");
color_dance(3,PKT_red,PKT_blue);
status = write(s, PKT_backled, sizeof(PKT_backled));
sleep(1);
ROS_INFO("Sphero color test completed");
while (ros::ok())
{
ros::spinOnce(); //get new velocity commands
status = write(s, PKT_vel, sizeof(PKT_vel)); //write those commands
ROS_INFO("Velocity Message Sent, Status: %f",status); //debug
//close(s); //close the socket when done
r.sleep();
}//while ros ok
}// if socket is ok/ros lives
else
{
ROS_ERROR("ROS is working but Device Busy/Broken/Oops");
}
}//main
bdaddr_t *strtoba(const char *str)
{
bdaddr_t b;
bdaddr_t *ba = bt_malloc(sizeof(*ba));
if (ba) {
str2ba(str, &b);
baswap(ba, &b);
}
return ba;
}
int main(int argc, char *argv[])
{
int fd;
bdaddr_t bdaddr;
uint8_t channel;
switch (argc) {
case 2:
str2ba(argv[1], &bdaddr);
channel = 1;
break;
case 3:
str2ba(argv[1], &bdaddr);
channel = atoi(argv[2]);
break;
default:
usage();
exit(-1);
}
if (bacmp(BDADDR_ANY, &bdaddr)) {
printf("Connecting to %s on channel %d\n", argv[1], channel);
fd = open_socket(&bdaddr, channel);
} else {
printf("Opening device %s\n", argv[1]);
fd = open_device(argv[1]);
}
if (fd < 0)
exit(-2);
at_command(fd, "ATZ\r\n", 10000);
at_command(fd, "AT+CPBS=\"ME\"\r\n", 10000);
at_command(fd, "AT+CPBR=1,100\r\n", 100000);
close(fd);
return 0;
}
int main(int argc, char** argv) {
if(argc < 3 || argc > 5) {
const char* exename = FileNameFromPath(argv[0]);
printf(
"Usage: %s <file> <address> [port] [maxPacketSize]\n"
"\n"
"Sends <file> to Bluetooth <address>:[port] using OBEX PUT\n"
"with a maximum packet size decided by the target device,\n"
"optionally limited by [maxPacketSize].\n"
"\n"
"If [port] is not specified, Service Search is used to find it.\n"
"\n"
"Example: %s MoSync.jar 010203040506 9\n",
exename, exename);
DEBUG_GETCH;
return -__COUNTER__;
}
MABtAddr address;
str2ba(argv[2], &address);
int port = -1;
if(argc > 3) {
port = atoi(argv[3]);
if(port < 1 || port > 30) {
printf("Bad port number: %i\n", port);
return -__COUNTER__;
}
}
int maxPacketSize = 0xffff;
if(argc > 4) {
maxPacketSize = atoi(argv[4]);
if(maxPacketSize < 1 || maxPacketSize > 0xffff) {
printf("Bad maxPacketSize: %i\n", maxPacketSize);
return -__COUNTER__;
}
}
Bluetooth::MABtInit();
int res = sendFile(argv[1], &address, port, maxPacketSize);
Bluetooth::MABtClose();
if(res != 1) {
printf("Result: %i\n", res);
return res;
} else {
printf("File sent successfully.\n");
return 0;
}
DEBUG_GETCH;
}
static int Wiimote_init(Wiimote* self, PyObject* args, PyObject *kwds)
{
static char *kwlist[] = {"bdaddr", "flags", NULL};
PyObject *PyObj;
cwiid_wiimote_t *wiimote = NULL;
char *str_bdaddr = NULL;
bdaddr_t bdaddr;
int flags = 0;
/* Overloaded function - if a single CObject is passed in, it's
* an existing CObject. Otherwise, create a new one */
if (PyTuple_Size(args) == 1) {
PyObj = PyTuple_GET_ITEM(args, 0);
if (PyCObject_Check(PyObj)) {
wiimote = PyCObject_AsVoidPtr(PyObj);
self->close_on_dealloc = 0;
}
}
if (!wiimote) {
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|si:cwiid.Wiimote.init",
kwlist, &str_bdaddr, &flags)) {
return -1;
}
if (str_bdaddr) {
if (str2ba(str_bdaddr, &bdaddr)) {
PyErr_SetString(PyExc_ValueError, "bad bdaddr");
return -1;
}
}
else {
bdaddr = *BDADDR_ANY;
}
Py_BEGIN_ALLOW_THREADS
wiimote = cwiid_open(&bdaddr, flags);
Py_END_ALLOW_THREADS
if (!wiimote) {
PyErr_SetString(PyExc_RuntimeError,
"Error opening wiimote connection");
return -1;
}
else {
self->close_on_dealloc = 1;
}
}
cwiid_set_data(wiimote, self);
self->wiimote = wiimote;
return 0;
}
int bluetooth_open(const char *addr, uint8_t channel, struct gn_statemachine *state)
{
bdaddr_t bdaddr;
struct sockaddr_rc raddr;
int fd;
if (str2ba((char *)addr, &bdaddr)) {
fprintf(stderr, _("Invalid bluetooth address \"%s\"\n"), addr);
return -1;
}
if ((fd = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)) < 0) {
perror(_("Can't create socket"));
return -1;
}
memset(&raddr, 0, sizeof(raddr));
raddr.rc_family = AF_BLUETOOTH;
bacpy(&raddr.rc_bdaddr, &bdaddr);
dprintf("Channel: %d\n", channel);
if (channel < 1) {
if (!strcmp(state->config.model, "gnapplet") ||
!strcmp(state->config.model, "symbian"))
channel = get_serial_channel(&bdaddr, 1);
else
channel = get_serial_channel(&bdaddr, 0);
}
dprintf("Channel: %d\n", channel);
/* If none channel found, fail. */
if (channel < 1) {
fprintf(stderr, _("Cannot find any appropriate rfcomm channel and none was specified in the config.\n"));
close(fd);
return -1;
}
dprintf("Using channel: %d\n", channel);
raddr.rc_channel = channel;
if (connect(fd, (struct sockaddr *)&raddr, sizeof(raddr)) < 0) {
perror(_("Can't connect"));
close(fd);
return -1;
}
/* Ignore errors. If the socket was not set in the async way,
* we can live with that.
*/
setNonblocking(fd);
return fd;
}
int init_bluetooth(char *btAddress){
struct sockaddr_rc addr={0};
int status;
nxtSocket = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
addr.rc_family = AF_BLUETOOTH;
addr.rc_channel = (uint8_t) 1;
str2ba(btAddress, &addr.rc_bdaddr);
status = connect(nxtSocket, (struct sockaddr *)&addr, sizeof(addr));
if(status <0){
perror("Error connecting Bluetooth");
return status;
}
return 0;
}
