void * coordinatesThread(void* arg)
{
int lg_message = LG_MESS_DEFAUT;
int n = *((int*)arg);
while (1) {
sleep(1);
pthread_mutex_lock(&messageMutex);
emettre(lg_message, msgSend, "11 ");
pthread_mutex_unlock(&messageMutex);
}
return NULL;
}
void Image::emettreImage(QString titre, int numeroLiaison)
{
bool ok;
// On compresse l'image dans un tableau
QByteArray baImage;
QBuffer bufImage(&baImage);
ok = labelImage->pixmap()->save(&bufImage, "jpeg", 70);
if (!ok)
qWarning("Probleme de compression de l'image (emettreImage - Image.cpp)");
// Taille des donnees
quint32 tailleCorps =
// Taille du titre
sizeof(quint16) + titre.size()*sizeof(QChar) +
// Taille de l'identifiant de l'image
sizeof(quint8) + idImage.size()*sizeof(QChar) +
// Taille de l'identifiant du joueur
sizeof(quint8) + idJoueur.size()*sizeof(QChar) +
// Taille de l'image
sizeof(quint32) + baImage.size();
// Buffer d'emission
char *donnees = new char[tailleCorps + sizeof(enteteMessage)];
// Creation de l'entete du message
enteteMessage *uneEntete;
uneEntete = (enteteMessage *) donnees;
uneEntete->categorie = image;
uneEntete->action = chargerImage;
uneEntete->tailleDonnees = tailleCorps;
// Creation du corps du message
int p = sizeof(enteteMessage);
// Ajout du titre
quint16 tailleTitre = titre.size();
memcpy(&(donnees[p]), &tailleTitre, sizeof(quint16));
p+=sizeof(quint16);
memcpy(&(donnees[p]), titre.data(), tailleTitre*sizeof(QChar));
p+=tailleTitre*sizeof(QChar);
// Ajout de l'identifiant de l'image
quint8 tailleIdImage = idImage.size();
memcpy(&(donnees[p]), &tailleIdImage, sizeof(quint8));
p+=sizeof(quint8);
memcpy(&(donnees[p]), idImage.data(), tailleIdImage*sizeof(QChar));
p+=tailleIdImage*sizeof(QChar);
// Ajout de l'identifiant du joueur
quint8 tailleIdJoueur = idJoueur.size();
memcpy(&(donnees[p]), &tailleIdJoueur, sizeof(quint8));
p+=sizeof(quint8);
memcpy(&(donnees[p]), idJoueur.data(), tailleIdJoueur*sizeof(QChar));
p+=tailleIdJoueur*sizeof(QChar);
// Ajout de l'image
quint32 tailleImage = baImage.size();
memcpy(&(donnees[p]), &tailleImage, sizeof(quint32));
p+=sizeof(quint32);
memcpy(&(donnees[p]), baImage.data(), tailleImage);
p+=tailleImage;
// Emission de l'image vers la liaison indiquee
emettre(donnees, tailleCorps + sizeof(enteteMessage), numeroLiaison);
// Liberation du buffer d'emission
delete[] donnees;
}
void LecteurAudio::emettreCommande(actionMusique action, QString nomFichier, quint32 position, int numeroLiaison)
{
int p;
quint16 tailleNomFichier;
// Donnees a emettre
char *donnees;
// Creation de l'entete du message
enteteMessage uneEntete;
uneEntete.categorie = musique;
uneEntete.action = action;
// Remplissage de l'entete et du corps en fonction de la commande envoyee
switch(action)
{
case nouveauMorceau :
uneEntete.tailleDonnees = sizeof(quint16) + nomFichier.size()*sizeof(QChar);
donnees = new char[uneEntete.tailleDonnees + sizeof(enteteMessage)];
// Ajout du nom du fichier dans le message
p = sizeof(enteteMessage);
tailleNomFichier = nomFichier.size();
memcpy(&(donnees[p]), &tailleNomFichier, sizeof(quint16));
p+=sizeof(quint16);
memcpy(&(donnees[p]), nomFichier.data(), tailleNomFichier*sizeof(QChar));
break;
case lectureMorceau :
uneEntete.tailleDonnees = 0;
donnees = new char[uneEntete.tailleDonnees + sizeof(enteteMessage)];
break;
case pauseMorceau :
uneEntete.tailleDonnees = 0;
donnees = new char[uneEntete.tailleDonnees + sizeof(enteteMessage)];
break;
case arretMorceau :
uneEntete.tailleDonnees = 0;
donnees = new char[uneEntete.tailleDonnees + sizeof(enteteMessage)];
break;
case nouvellePositionMorceau :
uneEntete.tailleDonnees = sizeof(quint32);
donnees = new char[uneEntete.tailleDonnees + sizeof(enteteMessage)];
// Ajout de la position dans le message
memcpy(&(donnees[sizeof(enteteMessage)]), &position, sizeof(quint32));
break;
default :
qWarning("Commande inconnue envoyee aux lecteurs audio des autres utilisateurs");
break;
}
// Recopie de l'entete en debut de message
memcpy(donnees, &uneEntete, sizeof(enteteMessage));
// Emission du message vers le serveur ou les clients...
if (numeroLiaison == -1)
emettre(donnees, uneEntete.tailleDonnees + sizeof(enteteMessage));
// ...ou bien vers un client en particulier
else
emettre(donnees, uneEntete.tailleDonnees + sizeof(enteteMessage), numeroLiaison);
// Liberation du buffer d'emission
delete[] donnees;
}
int main() {
struct sigaction action;
/* autres variables (a completer) */
int semid,i;
setbuf(stdout, NULL);
/* Creation du segment de memoire partagee */
// A completer
if ( (nb_recepteurs = init_shm(sizeof(t_segpart))) == NULL)
{
perror("init_shm");
exit(1);
}
nb_recepteurs->a = 0;
/* creation des semaphores */
// A completer
if ((semid = creer_sem(NR+2)) == -1)
{
perror("creer_sem");
exit(1);
}
/* initialisation des semaphores */
// A completer
init_un_sem(EMET,1);
init_un_sem(RECEPT1,0);
init_un_sem(RECEPT2,0);
init_un_sem(RECEPT3,0);
init_un_sem(RECEPT4,0);
init_un_sem(RECEPT5,0);
init_un_sem(NBRECEPT,1);
/* creation des processus emetteurs */
for (i=0; i < NE ;i++)
{
if ((emet_pid[i] = fork()) == -1)
{
perror("fork");
exit(0);
}
else if (emet_pid[i] == 0)
{
emettre(i);
}
}
// A completer - les pid des processus crees doivent
// etre stockes dans le tableau emet_pid
/* creation des processus recepteurs */
// A completer - les pid des processus crees doivent
// etre stockes dans le tableau recep_pid
for (i=0; i < NR ;i++)
{
if ((recep_pid[i] = fork()) == -1)
{
perror("fork");
exit(0);
}
else if (recep_pid[i] == 0)
{
reception(i+1);
}
}
/* redefinition du traitement de Ctrl-C pour arreter le programme */
sigemptyset(&action.sa_mask);
action.sa_flags = 0;
action.sa_handler = handle_sigint;
sigaction(SIGINT, &action, 0);
pause(); /* attente du Ctrl-C */
return EXIT_SUCCESS;
}
int main (int argc, char** argv)
{
int choix;
int lg_message = LG_MESS_DEFAUT;
int *n;
char * msg = malloc(sizeof(char)*lg_message);
pthread_mutex_t displayMutex = PTHREAD_MUTEX_INITIALIZER;
initBeaconsLocation(beaconsLocation, (int) NUMBER_BEACONS);
n = malloc(sizeof(int));
//*n = 500000;
*n = 1;
char * adr = malloc(12*sizeof(char));
adr = ADR_DIST;
msgSend = malloc(sizeof(char)*lg_message);
msgRcv = malloc(sizeof(char)*lg_message);
pthread_t tid[2];
pthread_create(&tid[0], NULL, receiverThread, NULL);
// initialisation socket sender.
// initialisation ici car on a besoin d'un receiver à l'écoute pour lancer le sender, donc pour le test en localhost on le fait après le receiver
//printf("before %s\n", adr);
usleep(30000);
initSender(adr);
//printf("%s\n", adr);
pthread_create(&tid[1], NULL, coordinatesThread, n);
pthread_mutex_lock(&displayMutex);
printf("\n Drone position : \n");
printf(" Send : \n\n");
pthread_mutex_unlock(&displayMutex);
while(1) {
pthread_mutex_lock(&displayMutex);
printf("What do you want to do ?\n");
printf("0 -> Calibration (drone must lay flat on the floor)\n");
printf("1 -> Magnetic calibration\n");
printf("2 -> landing\n");
printf("3 -> take off\n");
printf("4 -> move roll \n");
printf("5 -> move pitch\n");
printf("6 -> move pitch roll\n");
printf("7 -> emergency\n");
printf("8 -> anti emergency\n");
printf("9 -> start mission\n");
printf("10 -> stop mission\n");
printf("-1 to close the programm\n");
pthread_mutex_unlock(&displayMutex);
scanf("%d", &choix);
getchar();
pthread_mutex_lock(&displayMutex);
printf("\033[%dA", 2);
printf("\033[%dM", 1);
printf("\033[%dJ", 2);
pthread_mutex_unlock(&displayMutex);
if (choix >= 0 && choix < 10) {
sprintf(msg, " %d ", choix);
}
else {
sprintf(msg, "%d ", choix);
}
if (choix == 9) {
pthread_mutex_lock(&displayMutex);
printf("\033[%dA", 12);
printf("\033[%dM", 12);
printf("Choose your beacon (from 0 to 7)\n");
printf("0 -> %s\n", beaconsLocation[0]);
printf("1 -> %s\n", beaconsLocation[1]);
printf("2 -> %s\n", beaconsLocation[2]);
printf("3 -> %s\n", beaconsLocation[3]);
printf("4 -> %s\n", beaconsLocation[4]);
printf("5 -> %s\n", beaconsLocation[5]);
printf("6 -> %s\n", beaconsLocation[6]);
printf("7 -> %s\n", beaconsLocation[7]);
printf("\n\n");
pthread_mutex_unlock(&displayMutex);
scanf("%d", &choix);
strcat(msg, beaconsLocation[choix]);
//printf("######## msg : %s\n", msg);
if (choix >= 0 && choix <=7) {
pthread_mutex_lock(&messageMutex);
emettre(lg_message, msgSend, msg);
pthread_mutex_unlock(&messageMutex);
}
else {
pthread_mutex_lock(&displayMutex);
printf("incorrect choice\n");
pthread_mutex_unlock(&displayMutex);
}
pthread_mutex_lock(&displayMutex);
printf("\033[%dA", 12);
printf("\033[%dM", 12);
printf("\033[%dJ", 2);
pthread_mutex_unlock(&displayMutex);
}
else if (choix >= 0 && choix <= 10) {
pthread_mutex_lock(&messageMutex);
emettre(lg_message, msgSend, msg);
pthread_mutex_unlock(&messageMutex);
}
else if (choix == -1) {
pthread_cancel(tid[0]);
pthread_cancel(tid[1]);
closeSender();
closeReceiver();
break;
}
else {
pthread_mutex_lock(&displayMutex);
printf("incorrect choice\n");
pthread_mutex_unlock(&displayMutex);
}
}
// pthread_exit(NULL);
return 0;
}
