// search
static PyObject *
sess_search(PySDPSessionObject *s, PyObject *args, PyObject *kwds)
{
char *uuid_str = 0;
uuid_t uuid = { 0 };
PyObject *result = 0;
if (!PyArg_ParseTuple(args, "s", &uuid_str)) return NULL;
// convert the UUID string into a uuid_t
if( ! str2uuid( uuid_str, &uuid ) ) {
PyErr_SetString(PyExc_ValueError, "invalid UUID!");
return NULL;
}
// make sure the SDP session is open
if( ! s->session ) {
PyErr_SetString( bluetooth_error, "SDP session is not active!" );
return 0;
}
// perform the search
result = do_search( s->session, &uuid );
return result;
}
LGATTUUID::LGATTUUID(const char *uuid)
{
str2uuid(_uuid.uuid, uuid);
_uuid.length = sizeof(_uuid.uuid);
//Serial.print(*this);
//Serial.println();
}
// Overloaded copy operators to allow initialisation of LGATTUUID objects from other types
LGATTUUID& LGATTUUID::operator=(const char *uuid)
{
_uuid.length = sizeof(_uuid.uuid);
str2uuid(_uuid.uuid, uuid);
return *this;
}
int main(void) {
int i, j, err, sock, dev_id = -1;
struct hci_dev_info dev_info;
inquiry_info *info = NULL;
bdaddr_t target;
char addr[19] = { 0 };
char name[248] = { 0 };
uuid_t uuid = { 0 };
//Change this to your apps UUID
char *uuid_str="4e5d48e0-75df-11e3-981f-0800200c9a66";
uint32_t range = 0x0000ffff;
sdp_list_t *response_list = NULL, *search_list, *attrid_list;
int s, loco_channel = -1, status;
struct sockaddr_rc loc_addr = { 0 };
pthread_t blueThread;
FILE *fp_Setting;
char message_Buffer[64];
char mode[30], language[16], topic[16], topicLen[16];
size_t len = 16;
(void) signal(SIGINT, SIG_DFL);
changeTopic_flag = 1;
///////////////////////////MRAA/////////////////////////////
//Initialize MRAA
mraa_init();
//Initialize MRAA Pin 8 == IO8 == GP49
mraa_gpio_context BearButton = mraa_gpio_init(8);
//Check for successful initialization or else return
if (BearButton == NULL){
printf("Error initializing Push to Talk Pin, IO2\n");
return -1;
}
//Set pin to an input
mraa_gpio_dir(BearButton, MRAA_GPIO_IN);
printf("Set Pin to an input\n");
int curr_pin = mraa_gpio_get_pin(BearButton);
printf("The current pin number is %d\n", curr_pin);
int curr_raw = mraa_gpio_get_pin_raw(BearButton);
printf("The raw pin number is %d\n", curr_raw);
printf("Going to start reading the button via polling\n");
//////////////////////AWS///////////////////////////////////
aws_flag = 0;
IoT_Error_t rc = NONE_ERROR;
char HostAddress[255] = AWS_IOT_MQTT_HOST;
char certDirectory[PATH_MAX + 1] = "/AWS/SDK/certs/";
uint32_t port = AWS_IOT_MQTT_PORT;
MQTTMessageParams Msg = MQTTMessageParamsDefault;
Msg.qos = QOS_0;
char cPayload[100];
Msg.pPayload = (void *) cPayload;
char rootCA[PATH_MAX + 1];
char clientCRT[PATH_MAX + 1];
char clientKey[PATH_MAX + 1];
char cafileName[] = AWS_IOT_ROOT_CA_FILENAME;
char clientCRTName[] = AWS_IOT_CERTIFICATE_FILENAME;
char clientKeyName[] = AWS_IOT_PRIVATE_KEY_FILENAME;
sprintf(rootCA, "/%s/%s", certDirectory, cafileName);
sprintf(clientCRT, "/%s/%s", certDirectory, clientCRTName);
sprintf(clientKey, "/%s/%s", certDirectory, clientKeyName);
MQTTConnectParams connectParams = MQTTConnectParamsDefault;
connectParams.KeepAliveInterval_sec = 14000;
connectParams.isCleansession = true;
connectParams.MQTTVersion = MQTT_3_1_1;
connectParams.pClientID = "TED";
connectParams.pHostURL = HostAddress;
connectParams.port = port;
connectParams.isWillMsgPresent = false;
connectParams.pRootCALocation = rootCA;
connectParams.pDeviceCertLocation = clientCRT;
connectParams.pDevicePrivateKeyLocation = clientKey;
connectParams.mqttCommandTimeout_ms = 2000;
connectParams.tlsHandshakeTimeout_ms = 5000;
connectParams.isSSLHostnameVerify = true;// ensure this is set to true for production
connectParams.disconnectHandler = disconnectCallbackHandler;
MQTTPublishParams CurriculumParams = MQTTPublishParamsDefault;
CurriculumParams.pTopic = "Bear/Curriculum/Request";
MQTTPublishParams MetricsParams = MQTTPublishParamsDefault;
MetricsParams.pTopic = "Bear/Curriculum/Metrics";
///////////////////////////////////////////////////////////////////////////////////////
dev_id = hci_get_route(NULL);
if (dev_id < 0) {
perror("No Bluetooth Adapter Available");
exit(1);
}
if (hci_devinfo(dev_id, &dev_info) < 0) {
perror("Can't get device info");
exit(1);
}
sock = hci_open_dev( dev_id );
if (sock < 0) {
perror("HCI device open failed");
free(info);
exit(1);
}
if( !str2uuid( uuid_str, &uuid ) ) {
perror("Invalid UUID");
free(info);
exit(1);
}
do {
printf("Scanning ...\n");
sdp_session_t *session;
int retries;
int foundit, responses;
str2ba(TABLET_ADDRESS,&target);
memset(name, 0, sizeof(name));
if (hci_read_remote_name(sock, &target, sizeof(name), name, 0) < 0){
strcpy(name, "[unknown]");
}
printf("Found %s %s, searching for the the desired service on it now\n", addr, name);
// connect to the SDP server running on the remote machine
sdpconnect:
session = 0; retries = 0;
while(!session) {
session = sdp_connect( BDADDR_ANY, &target, SDP_RETRY_IF_BUSY );
if(session) break;
if(errno == EALREADY && retries < 5) {
perror("Retrying");
retries++;
sleep(1);
continue;
}
break;
}
if ( session == NULL ) {
perror("Can't open session with the device");
continue;
}
search_list = sdp_list_append( 0, &uuid );
attrid_list = sdp_list_append( 0, &range );
err = 0;
err = sdp_service_search_attr_req( session, search_list, SDP_ATTR_REQ_RANGE, attrid_list, &response_list);
sdp_list_t *r = response_list;
sdp_record_t *rec;
// go through each of the service records
foundit = 0;
responses = 0;
for (; r; r = r->next ) {
responses++;
rec = (sdp_record_t*) r->data;
sdp_list_t *proto_list;
// get a list of the protocol sequences
if( sdp_get_access_protos( rec, &proto_list ) == 0 ) {
sdp_list_t *p = proto_list;
// go through each protocol sequence
for( ; p ; p = p->next ) {
sdp_list_t *pds = (sdp_list_t*)p->data;
// go through each protocol list of the protocol sequence
for( ; pds ; pds = pds->next ) {
// check the protocol attributes
sdp_data_t *d = (sdp_data_t*)pds->data;
int proto = 0;
for( ; d; d = d->next ) {
switch( d->dtd ) {
case SDP_UUID16:
case SDP_UUID32:
case SDP_UUID128:
proto = sdp_uuid_to_proto( &d->val.uuid );
break;
case SDP_UINT8:
if( proto == RFCOMM_UUID ) {
printf("rfcomm channel: %d\n",d->val.int8);
loco_channel = d->val.int8;
foundit = 1;
}
break;
}
}
}
sdp_list_free( (sdp_list_t*)p->data, 0 );
}
sdp_list_free( proto_list, 0 );
}
if (loco_channel > 0)
break;
}
printf("No of Responses %d\n", responses);
if ( loco_channel > 0 && foundit == 1 ) {
printf("Found service on this device, now gonna blast it with dummy data\n");
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
loc_addr.rc_family = AF_BLUETOOTH;
loc_addr.rc_channel = loco_channel;
loc_addr.rc_bdaddr = *(&target);
status = connect(s, (struct sockaddr *)&loc_addr, sizeof(loc_addr));
if( status < 0 ) {
perror("uh oh");
}
rc = pthread_create(&blueThread, NULL, threadListen, (void *)s);
if (rc){
printf("ERROR: %d\n", rc);
exit(1);
}
MQTTSubscribeParams subParams = MQTTSubscribeParamsDefault;
//Loop through trying to subscribe to AWS incase the first attempt fails, so will keep trying until the app sends the edison proper network info.
do{
INFO("Connecting...");
rc = aws_iot_mqtt_connect(&connectParams);
if (NONE_ERROR != rc) {
ERROR("Error(%d) connecting to %s:%d", rc, connectParams.pHostURL, connectParams.port);
}
subParams.mHandler = MQTTcallbackHandler;
subParams.pTopic = "Bear/Curriculum/Response";
subParams.qos = QOS_0;
if (NONE_ERROR == rc) {
INFO("Subscribing...");
rc = aws_iot_mqtt_subscribe(&subParams);
if (NONE_ERROR != rc) {
ERROR("Error subscribing");
}
}
sleep(1);
}while(NONE_ERROR != rc);
aws_flag = 1;
//////////////////////////Start of teaching stuff//////////////////////////////////////////
do {
if(changeTopic_flag){
sprintf(cPayload, "{\"BearID\":\"%s\"}",BEARID);
Msg.PayloadLen = strlen(cPayload) + 1;
CurriculumParams.MessageParams = Msg;
rc = aws_iot_mqtt_publish(&CurriculumParams);
while(rc == NONE_ERROR && changeTopic_flag){
rc = aws_iot_mqtt_yield(100);
INFO("-->sleep");
sleep(1);
}
changeTopic_flag = 0;
}
fp_Setting = fopen("/Curriculum/BearSettings.txt", "r");
fgets(language, sizeof(language), fp_Setting);
fgets(mode, sizeof(mode), fp_Setting);
fgets(topic, sizeof(topic), fp_Setting);
fgets(topicLen, sizeof(topicLen), fp_Setting);
language[strlen(language)-1] = 0;
mode[strlen(mode)-1] = 0;
topic[strlen(topic)-1] = 0;
topicLen[strlen(topicLen)-1] = 0;
fclose(fp_Setting);
//Wait for the tablet to tell the edison to start the lesson
while(strcmp(threadMessage, "learning")){
printf("Waiting for learning, got: %s\n", threadMessage);
if(!strcmp(threadMessage, "crash")){
memset(threadMessage, 0, sizeof(threadMessage));
goto CRASHED;
}
memset(threadMessage, 0, sizeof(threadMessage));
sleep(1);
}
printf("Current Mode: %s\n", mode);
printf("Current Language: %s\n", language);
printf("Current topic: %s\n", topic);
//Call a different function depending on what teaching mode it is, also write to the tablet based on the topic info and lesson
if(!strcmp(mode, "Repeat After Me")){
sprintf(message_Buffer,"%s,1,%s",language, topicLen);
status = write(s,message_Buffer,sizeof(message_Buffer));
if(!strcmp(language, "English")){
status = repeat_after_me_english(s, topic, MetricsParams, BearButton);
}
else{
status = repeat_after_me_foreign(s, language, topic, MetricsParams, BearButton);
}
}
else if(!strcmp(mode, "English to Foreign")){
sprintf(message_Buffer,"%s,3,%s",language, topicLen);
status = write(s,message_Buffer,sizeof(message_Buffer));
status = english_to_foreign(s, language, topic, MetricsParams, BearButton);
}
else if(!strcmp(mode, "Foreign to English")){
sprintf(message_Buffer,"%s,2,%s",language, topicLen);
status = write(s,message_Buffer,sizeof(message_Buffer));
status = foreign_to_english(s, language, topic, MetricsParams, BearButton);
}
changeTopic_flag = 1;
printf("Changing Topic");
sleep(5);
} while (status > 0);
CRASHED:
printf("\nBluetooth Disconnected\n");
close(s);
sdp_record_free( rec );
}
sdp_close(session);
if (loco_channel > 0) {
goto sdpconnect;
//break;
}
sleep(1);
} while (1);
printf("Exiting...\n");
}
void *main_bluetooth(void *arg) {
int i, err, sock, dev_id = -1;
int num_rsp = 0, max_rsp = 5, flags = 0, length = 4; /* [1.28 *<length>]seconds [1.28*4 = 5.12] seconds */
char addr[19] = {0};
char cmd[100], cmd1[50];
char name[248] = {0}, bt_mac[19] = "00:00:00:00:00:00";
uuid_t uuid = {0};
int application_id = (int) *(int *) arg;
char uuid_str[50];
FILE *fd = NULL;
if (application_id == 2) {
printf("\nOpen application: Android Locomate Messaging\n");
strcpy(uuid_str, "66841278-c3d1-11df-ab31-001de000a901");
}
else if (application_id == 3) {
printf("\nOpen application: Spat Andriod Application\n");
strcpy(uuid_str, "66841278-c3d1-11df-ab31-001de000a903");
}
else if (application_id == 4) {
printf("\nOpen application: Bluetooth CAN application\n");
strcpy(uuid_str, "00001101-0000-1000-8000-00805F9B34FB");
fd = popen("cat /var/can.conf | grep BTCAN_MAC= | cut -d '=' -f 2", "r");
if (fd != NULL) {
fscanf(fd, "%s", bt_mac);
pclose(fd);
printf("Mac from conf file: %s\n", bt_mac);
}
}
else {
printf("\nOpen application: Locomate Safety Application\n");
strcpy(uuid_str, "66841278-c3d1-11df-ab31-001de000a902");
}
uint32_t range = 0x0000ffff;
sdp_list_t *response_list = NULL, *search_list, *attrid_list;
int status;
int responses;
int retries = 0;
struct sockaddr_rc loc_addr = {0};
signal(SIGINT, (void *) sig_int);
/* find the bluetooth device is available or not */
sprintf(cmd, "/usr/local/bin/hciconfig hci0 up");
system(cmd);
for (retries = 0; retries < 5; retries++) {
dev_id = hci_get_route(NULL);
if (dev_id < 0) {
perror("No Bluetooth Adapter Available\n");
sprintf(cmd, "/usr/local/bin/hciconfig hci0 down");
system(cmd);
sprintf(cmd1, "/usr/local/bin/hciconfig hci0 up");
system(cmd1);
printf("\nretry getting adapter : %d\n", retries);
}
else
break;
}
if (retries == 5) {
Btooth_forward = -1;
return NULL;
}
for (retries = 0; retries < 5; retries++) { //check for the socket
sock = hci_open_dev(dev_id);
if (sock < 0) {
perror("HCI device open failed");
retries++;
printf("\nretries sock : %d\n", retries);
}
else
break;
}
if (retries == 5) {
Btooth_forward = -2;
return NULL;
}
for (retries = 0; retries < 5; retries++) { //check uuid is correct or not
if (!str2uuid(uuid_str, &uuid)) {
perror("Invalid UUID");
retries++;
printf("\nretries str2 uuid : %d\n", retries);
}
else
break;
}
if (retries == 5) {
Btooth_forward = -3;
return NULL;
}
//printf("\nBluetooth Adapter Found \n");
info = (inquiry_info *) malloc(MAX_RSP * sizeof(inquiry_info));
while (1) { // loop to check and establish connection with other device
while (connection_established == FALSE) {
bzero(info, (MAX_RSP * sizeof(inquiry_info)));
num_rsp = hci_inquiry(dev_id, length, max_rsp, NULL, &info,
flags); // inquire for how many devices are available
if (num_rsp < 0) {
perror("Inquiry failed");
sched_yield();
sleep(1);
continue;
}
printf("Inquiry devices found : %d\n", num_rsp);
loco_channel = -1;
for (i = 0; i < num_rsp; i++) {
sdp_session_t *session;
ba2str(&(info + i)->bdaddr, addr);
printf("\nFound Mac: %s ", addr);
if (application_id == 4 && strcmp("00:00:00:00:00:00", bt_mac)) // check for appid and mac_id
if (strcasecmp(addr, bt_mac))
continue;
memset(name, 0, sizeof(name));
if (hci_read_remote_name(sock, &(info + i)->bdaddr, sizeof(name), name, 8000) < 0) //get devices by name
strcpy(name, "[unknown]");
printf("Found : %s name : [[ %s ]]\n", addr, name);
// connect to the SDP server running on the remote machine
session = NULL;
retries = 0;
while (!session) {
session = sdp_connect(BDADDR_ANY, &(info + i)->bdaddr, 0);
if (session) break;
if (errno != 0) {
fprintf(stderr, "sdp_connect failed error no %d : %s \n", errno, strerror(errno));
}
if ((retries < 2) && ((errno == EALREADY))) {
retries++;
fprintf(stderr, "Retry sdp_connect %d\t", retries);
sched_yield();
usleep(300000);//300 ms
continue; //continue till 3 times
}
break;
} /* while(!session) */
if (session == NULL) {
if (i < (num_rsp - 1))
printf("Trying next device -> %d\n", i + 2);
continue;
}
search_list = NULL;
attrid_list = NULL;
response_list = NULL;
search_list = sdp_list_append(NULL, &uuid); //append list of uuids
attrid_list = sdp_list_append(NULL, &range); // append list of attributes
err = 0;
err = sdp_service_search_attr_req(session, search_list, SDP_ATTR_REQ_RANGE, attrid_list,
&response_list); //search for attributes from list
sdp_list_t *r = response_list;
responses = 0;
// go through each of the service records
for (; r; r = r->next) {
responses++;
sdp_record_t *rec = (sdp_record_t *) r->data;
sdp_list_t *proto_list;
// get a list of the protocol sequences
if (sdp_get_access_protos(rec, &proto_list) == 0) {
sdp_list_t *p = proto_list;
// go through each protocol sequence
for (; p; p = p->next) {
sdp_list_t *pds = (sdp_list_t *) p->data;
// go through each protocol list of the protocol sequence
for (; pds; pds = pds->next) {
// check the protocol attributes
sdp_data_t *d = (sdp_data_t *) pds->data;
int proto = 0;
for (; d; d = d->next) {
switch (d->dtd) {
case SDP_UUID16:
case SDP_UUID32:
case SDP_UUID128:
proto = sdp_uuid_to_proto(&d->val.uuid);
break;
case SDP_UINT8:
if (proto == RFCOMM_UUID) {
printf("rfcomm channel: %d\n", d->val.int8);
loco_channel = d->val.int8;
}
break;
} /* switch(t->dtd) */
} /* for( ; d; d = d->next) */
} /* for( ; pds ; pds = pds->next) */
sdp_list_free((sdp_list_t *) p->data, 0);
} /* for( ; p; p = p->next) */
sdp_list_free(proto_list, 0);
} /* if(sdp_get_access_protos(rec, &proto_list)) */
sdp_record_free(rec);
if (loco_channel > 0) {
break;
}
} /* for (; r; r = r->next) */
sdp_list_free(response_list, 0);
sdp_list_free(search_list, 0);
sdp_list_free(attrid_list, 0);
printf("No of services= %d on device %d \n", responses, i + 1);
if (loco_channel > 0) {
// printf("Found Locomate Safety Application on device: name [%s], sending message now\n",name);
btooth_socket = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
loc_addr.rc_family = AF_BLUETOOTH;
loc_addr.rc_channel = loco_channel;
loc_addr.rc_bdaddr = (info + i)->bdaddr;
status = connect(btooth_socket, (struct sockaddr *) &loc_addr, sizeof(loc_addr));
if (status < 0) {
perror("\nuh oh: Btooth socket not created\n");
Btooth_forward = -5;
}
else {
sdp_close(session);
Btooth_forward = 1;
connection_established = TRUE;
break;
}
}
sdp_close(session);
} /* for (i = 0; i < num_rsp; i++) */
if (connection_established == FALSE) {
printf("Scanning again\n");
//sprintf(cmd, "/usr/local/bin/hciconfig hci0 down");
//system(cmd);
sprintf(cmd1, "/usr/local/bin/hciconfig hci0 up");
system(cmd1);
sched_yield();
sleep(1);
}
else {
printf("***Connection established***\n");
}
} /* while(connection_established == ...) */
sched_yield();
sleep(3); // wait for 3seconds, before next check
}
}
