hci_controller_t hci_open_controller(bt_address_t *mac, char *name) {
hci_controller_t res = {0};
res.state = HCI_STATE_CLOSED;
struct hci_dev_info info;
hci_socket_t hci_socket = open_hci_socket(mac);
char real_name[8] = "UNKNOWN";
if (hci_socket.sock < 0) {
return res;
}
list_push(&(res.sockets_list), &hci_socket, sizeof(hci_socket_t));
if (hci_devinfo(hci_socket.dev_id, &info) >= 0) {
strncpy(real_name, info.name, 8);
if (!mac) {
*mac = info.bdaddr;
}
}
res.device = bt_device_create(*mac, PUBLIC_DEVICE_ADDRESS, real_name, name);
res.state = HCI_STATE_OPEN;
res.interrupted = 0;
return res;
}
int main(int arc, char**argv) {
if (arc != 2) {
print_trace(TRACE_ERROR, "Veuillez indiquer un fichier où stocker la matrice de calibration.\n");
return EXIT_FAILURE;
}
struct Matrix *matrice = create_matrix(NB_LIGNES,NB_COLONNES, NUM_CAPTORS);
pthread_mutex_init(&mutexMatrice, NULL);
for (uint8_t i = 0; i < NUM_CAPTORS; i++) {
mesures[i] = calloc(200, sizeof(char));
}
bdaddr_t controllerAdd, server1Mac, server2Mac, server3Mac, sensorMac;
str2ba(btControllerAdd, &controllerAdd);
str2ba(server1Add, &server1Mac);
str2ba(server2Add, &server2Mac);
str2ba(server3Add, &server3Mac);
str2ba(sensorAdd, &sensorMac);
hci_controller_t hci_controller = hci_open_controller(&controllerAdd, "MAIN_SERVER");
sensor = bt_device_create(sensorMac, PUBLIC_DEVICE_ADDRESS, NULL, "SENSOR_TAG");
server1 = bt_device_create(server1Mac, PUBLIC_DEVICE_ADDRESS, NULL, "SERVER_1");
server2 = bt_device_create(server2Mac, PUBLIC_DEVICE_ADDRESS, NULL, "SERVER_2");
server3 = bt_device_create(server3Mac, PUBLIC_DEVICE_ADDRESS, NULL, "SERVER_3");
hci_LE_clear_white_list(NULL, &hci_controller);
hci_LE_add_white_list(NULL, &hci_controller, sensor);
// Création des trois clients :
l2cap_client_t clients[NUM_CAPTORS-1] = {0};
l2cap_client_create(&clients[0], &server1Mac, 0x1001, 500, NULL, &(send_req_func));
l2cap_client_create(&clients[1], &server2Mac, 0x1001, 500, NULL, &(send_req_func));
l2cap_client_create(&clients[2], &server3Mac, 0x1001, 500, NULL, &(send_req_func));
if (l2cap_client_connect(&clients[0]) != 0) {
perror("client_connect : unable to connect client 1");
return EXIT_FAILURE;
}
if (l2cap_client_connect(&clients[1]) != 0) {
perror("client_connect : unable to connect client 2");
return EXIT_FAILURE;
}
if (l2cap_client_connect(&clients[2]) != 0) {
perror("client_connect : unable to connect client 3");
return EXIT_FAILURE;
}
fprintf(stderr, "\n-------------------\n");
fprintf(stderr, "----Calibration----\n");
fprintf(stderr, "-------------------\n");
pthread_t clients_threads[NUM_CAPTORS];
struct routine_data_t routine_data[NUM_CAPTORS];
for (uint8_t k = 0; k < NUM_CAPTORS; k++) {
routine_data[k].timeout = 4500;
routine_data[k].num_captor = k;
routine_data[k].hci_controller = &hci_controller;
routine_data[k].sensor = sensor;
if (k < NUM_CAPTORS-1) {
routine_data[k].client = &(clients[k]);
} else {
routine_data[k].client = NULL;
}
routine_data[k].matrice = matrice;
}
char command[20] = {0};
char *status;
char retry = 0;
for (uint8_t i = 0; i < NB_LIGNES; i++) {
for (uint8_t j = 0; j < NB_COLONNES; j++) {
scan:
retry = 0;
fprintf(stdout, "Position courante : %i, %i\n", i, j);
scanf("%s", command);
for (uint8_t k = 0; k < NUM_CAPTORS; k++) {
routine_data[k].num_row = i;
routine_data[k].num_col = j;
pthread_create(&(clients_threads[k]), NULL,
&(get_rssi_thread_routine),
(void *)&routine_data[k]);
}
for (uint8_t k = 0; k < 4; k ++) {
pthread_join(clients_threads[k], (void **)&status);
retry = retry || *status;
}
if (retry) {
print_trace(TRACE_WARNING, "Attention : impossible d'acquérir les mesures pour cette case, veuillez réessayer.\n");
goto scan;
}
}
}
// Fermeture des clients :
// Envoie des demandes de fin de connexion :
l2cap_client_send(&clients[0], 3000, CLIENT_CLOSE_CONNECTION);
l2cap_client_send(&clients[1], 3000, CLIENT_CLOSE_CONNECTION);
l2cap_client_send(&clients[2], 3000, CLIENT_CLOSE_CONNECTION);
// Destruction des clients :
l2cap_client_close(&clients[0]);
l2cap_client_close(&clients[1]);
l2cap_client_close(&clients[2]);
display_matrix(matrice);
save_matrix(argv[1], *matrice);
pthread_mutex_destroy(&mutexMatrice);
hci_close_controller(&hci_controller);
display_hci_socket_list(hci_controller.sockets_list);
bt_destroy_device_table();
}
