Wie kommuniziere ich zwischen Himbeer-Pis über WLAN?

Wie kommuniziere ich zwischen 2 Himbeer-Pis mit WiFi-Dongles? Ich habe die 2 WiFi-Dongles mit dem Router verbunden, weiß aber nicht, wie ich sie zur Kommunikation bringen soll. In diesem Fall verwende ich das Netzwerk für 2 Mikromäuse, um zu kommunizieren.

Es gibt mehrere Ansätze, um das zu erreichen, was Sie wollen. Die Art und Weise, wie ich sie beschreiben werde, wird wahrscheinlich eine Lernkurve haben, weil ich C verwendet habe . Die meisten Informationen, die ich verwendet habe, stammen aus dieser sehr hilfreichen Anleitung .

Bei dieser Methode benötigen Sie einen Client und einen Server , um zwischen den beiden Raspberry Pis zu kommunizieren. Der Informationsaustausch zwischen Client und Server ist in diesem Diagramm zusammengefasst:

Hier ist ein C-Code für einen Server und einen Client. Dieser Server sendet lediglich die Zeichenfolge "Hello, World! \ N" über eine Stream-Verbindung. Alles, was Sie tun müssen, um diesen Server zu testen, ist, ihn in einem Fenster auszuführen und von einem anderen mit ihm zu telneten:

$ telnet remotehostname 3490

(wobei remotehostname der Name des Computers ist, auf dem Sie ihn ausführen)

Hier ist der server.cCode:

/*
** server.c -- a stream socket server demo
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <signal.h>

#define PORT "3490"  // the port users will be connecting to

#define BACKLOG 10   // how many pending connections queue will hold

void sigchld_handler(int s)
{
    while(waitpid(-1, NULL, WNOHANG) > 0);
}

// get sockaddr, IPv4 or IPv6:
void *get_in_addr(struct sockaddr *sa)
{
    if (sa->sa_family == AF_INET) {
        return &(((struct sockaddr_in*)sa)->sin_addr);
    }

    return &(((struct sockaddr_in6*)sa)->sin6_addr);
}

int main(void)
{
    int sockfd, new_fd;  // listen on sock_fd, new connection on new_fd
    struct addrinfo hints, *servinfo, *p;
    struct sockaddr_storage their_addr; // connector's address information
    socklen_t sin_size;
    struct sigaction sa;
    int yes=1;
    char s[INET6_ADDRSTRLEN];
    int rv;

    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_PASSIVE; // use my IP

    if ((rv = getaddrinfo(NULL, PORT, &hints, &servinfo)) != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
        return 1;
    }

    // loop through all the results and bind to the first we can
    for(p = servinfo; p != NULL; p = p->ai_next) {
        if ((sockfd = socket(p->ai_family, p->ai_socktype,
                p->ai_protocol)) == -1) {
            perror("server: socket");
            continue;
        }

        if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes,
                sizeof(int)) == -1) {
            perror("setsockopt");
            exit(1);
        }

        if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
            close(sockfd);
            perror("server: bind");
            continue;
        }

        break;
    }

    if (p == NULL)  {
        fprintf(stderr, "server: failed to bind\n");
        return 2;
    }

    freeaddrinfo(servinfo); // all done with this structure

    if (listen(sockfd, BACKLOG) == -1) {
        perror("listen");
        exit(1);
    }

    sa.sa_handler = sigchld_handler; // reap all dead processes
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    if (sigaction(SIGCHLD, &sa, NULL) == -1) {
        perror("sigaction");
        exit(1);
    }

    printf("server: waiting for connections...\n");

    while(1) {  // main accept() loop
        sin_size = sizeof their_addr;
        new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
        if (new_fd == -1) {
            perror("accept");
            continue;
        }

        inet_ntop(their_addr.ss_family,
            get_in_addr((struct sockaddr *)&their_addr),
            s, sizeof s);
        printf("server: got connection from %s\n", s);

        if (!fork()) { // this is the child process
            close(sockfd); // child doesn't need the listener
            if (send(new_fd, "Hello, world!", 13, 0) == -1)
                perror("send");
            close(new_fd);
            exit(0);
        }
        close(new_fd);  // parent doesn't need this
    }

    return 0;
}

Hier ist der client.cCode:

/*
** client.c -- a stream socket client demo
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>

#include <arpa/inet.h>

#define PORT "3490" // the port client will be connecting to 

#define MAXDATASIZE 100 // max number of bytes we can get at once 

// get sockaddr, IPv4 or IPv6:
void *get_in_addr(struct sockaddr *sa)
{
    if (sa->sa_family == AF_INET) {
        return &(((struct sockaddr_in*)sa)->sin_addr);
    }

    return &(((struct sockaddr_in6*)sa)->sin6_addr);
}

int main(int argc, char *argv[])
{
    int sockfd, numbytes;  
    char buf[MAXDATASIZE];
    struct addrinfo hints, *servinfo, *p;
    int rv;
    char s[INET6_ADDRSTRLEN];

    if (argc != 2) {
        fprintf(stderr,"usage: client hostname\n");
        exit(1);
    }

    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    if ((rv = getaddrinfo(argv[1], PORT, &hints, &servinfo)) != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
        return 1;
    }

    // loop through all the results and connect to the first we can
    for(p = servinfo; p != NULL; p = p->ai_next) {
        if ((sockfd = socket(p->ai_family, p->ai_socktype,
                p->ai_protocol)) == -1) {
            perror("client: socket");
            continue;
        }

        if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
            close(sockfd);
            perror("client: connect");
            continue;
        }

        break;
    }

    if (p == NULL) {
        fprintf(stderr, "client: failed to connect\n");
        return 2;
    }

    inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr),
            s, sizeof s);
    printf("client: connecting to %s\n", s);

    freeaddrinfo(servinfo); // all done with this structure

    if ((numbytes = recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1) {
        perror("recv");
        exit(1);
    }

    buf[numbytes] = '\0';

    printf("client: received '%s'\n",buf);

    close(sockfd);

    return 0;
}

Sie können weiter in diesem Handbuch lesen, das ich verlinkt habe, um zu erfahren, wie Sie eine erweiterte Kommunikation zwischen Clients und Servern entwickeln können.

Sie können dafür fast jede Ihrer bevorzugten Programmiersprachen verwenden ...

• Perl
• Java
• MONO.NET

Jede dieser Bibliotheken verfügt über eine Art Kommunikationsbibliothek zum Erstellen von Net Sockets, z. B. virtuelle UART-Ports, über die Sie Binär- oder Textdaten auf hoher Ebene senden können, während die Bibliotheken die Fehler- und Flusskontrolle transparent behandeln.

Wenn Sie WiFi über Pis ausführen möchten, ohne es mit Ihrem Router (Infrastruktur) verbinden zu müssen, möchten Sie möglicherweise, dass diese in einem Ad-hoc-Netzwerk ausgeführt werden. Sie benötigen also keinen Router und müssen ihn nicht mit dem Internet verbinden.

Warnung

Wenn Sie den oben genannten Ad-hoc-Modus erreichen möchten, möchten Sie möglicherweise die richtigen WiFi-Adapter kaufen, die speziell den Ad-hoc-Modus ausführen. Dann müssen Sie RALINK-Chipsatz- basierte WiFi-Adapter kaufen . Meistens sind die Gemeinschaft verwendet die EDIMAX 7811Un WiFi Adapter - das ist toll , wenn Sie mit dem Internet verbinden möchten Infrastruktur - Modus , aber wenn Sie auf die Pis wollen talk - to- einander dann stellen Sie sicher , kaufen Sie die richtige Art von WiFi - Adapter.

Wenn Sie möchten, können Sie sich diesen Link ansehen, wenn Sie das Problem, das ich ansprechen möchte, besser verstehen möchten.