Quand j'ai essayé de faire une communication socket avec Raspberry Pi, le protocole était différent

J'ai essayé d'envoyer les paramètres de traitement du signal à RPi par communication socket, donc quand j'ai copié le code Internets pour la première communication socket, la fonction accept a généré une erreur "Argument invalide" et n'a pas fonctionné. Donc, j'ai découvert que accepter est une fonction utilisée lorsque le protocole est TCP et que le côté client l'envoie par UDP.

Pour une compréhension des grandes lignes du protocole UDP et du code serveur, reportez-vous au site suivant. Utiliser UDP: page Geek D'après l'explication du site ci-dessus, il semble qu'UDP soit bon si l'immédiateté est requise et que le paramètre est court dans une certaine mesure, j'ai donc décidé de réécrire la réception du serveur en UDP. Vous trouverez ci-dessous le code qui traite le signal dans la routine principale et reçoit les paramètres dans un autre thread. La partie qui acquiert les données audio est omise.

main.c

#include <netinet/in.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>


#define  PORT_NO    12345


/*Structure pour stocker les paramètres de réception*/
typedef struct {
    /*Paramètre approprié Groupe de variables*/
} socket_data_struct;


int serverSock;
struct sockaddr_in serverAddress;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;


/*Fonction d'initialisation de socket*/
int socketInit();      
/*Une fonction pour les threads qui reçoit des paramètres dans la communication socket*/                 
void* parameterReceive(void* pParam);


int socketInit()
{
    serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    if(serverSocket < 0) {
        return -1;
    }

    serverAddress.sin_family = AF_INET;
    serverAddress.sin_port = htons(PORT_NO);
    /*Recevoir des données adressées à toutes les adresses IP*/                     
    serverAddress.sin_addr.s_addr = htonl(INADDR_ANY); 

    if (bind(serverSocket, (struct sockaddr *)&serverAddress, sizeof(serverAddress)) != 0) {
        return -1;
    }
    
    return 0;
}

void* parameterReceive(void* pParam)
{
    socket_data_struct data;
    struct sockaddr_in senderInfo;    
    socklen_t addressLength;

    while (1) {
        recvfrom(serverSock, &data, sizeof(socket_data_struct), 0, (struct sockaddr *)&senderInfo, &addressLength);

        pthread_mutex_lock(&m);            
        
        /*Traitement des paramètres reçus*/

        pthread_mutex_unlock(&m);

        /*Echo a reçu des données au client*/
        sendto(serverSocket, (char *)&data, sizeof(socket_data_struct), 0, (struct sockaddr *)&senderInfo, addressLength);

        usleep(500);
    }

    close(serverSocket);
}


int main(void)
{
    pthread_t threadIdSocket; 

    if(socketInit()){
        return -1;
    }

    pthread_mutex_init(&m, NULL);
    pthread_create(&threadIdSocket, NULL, parameterReceive, NULL); 

    while(1){
        /*Contient le code DSP*/
    }

    pthread_join(threadIdSocket, NULL);  
    pthread_mutex_destroy(&m); 

    return 0;
}

Par précaution lors du traitement du signal et de la communication de socket en parallèle, ne pas pthread_join le thread de communication de socket avant la boucle while principale, mettre sleep dans la boucle while du thread de communication de socket, Est-ce à propos? De plus, bien sûr, le port à utiliser doit être ouvert avec ufw ou quelque chose. Vous pouvez désormais recevoir les paramètres de traitement du signal tout en effectuant le traitement du signal.