Line data    Source code

       1              : #include <stdio.h>
       2              : #include <stdlib.h>
       3              : #include <string.h>
       4              : 
       5              : #ifdef _WIN32
       6              :     #include <Winsock2.h>
       7              :     #include <direct.h>
       8              :     #define close closesocket
       9              :     #pragma comment(lib, "Ws2_32.lib")
      10              :     typedef int socklen_t;  // Define socklen_t for Windows
      11              : #else
      12              :     #include <unistd.h>
      13              :     #include <sys/types.h>
      14              :     #include <sys/socket.h>
      15              :     #include <netinet/in.h>
      16              :     #include <arpa/inet.h>
      17              :     #include <netdb.h>
      18              : #endif
      19              : 
      20              : #define PORT 55001
      21              : #define BUFFER_SIZE 1024
      22              : #define TIMEOUT_SEC 5
      23              : #define RETRY_COUNT 5
      24              : 
      25              : typedef struct {
      26              :     unsigned int total_pkt_len;
      27              :     unsigned int address;
      28              :     unsigned int command;
      29              :     unsigned int size;
      30              :     unsigned int status;
      31              : } Ctrl_Header;
      32              : 
      33              : typedef struct {
      34              :     Ctrl_Header header;
      35              :     unsigned int data[BUFFER_SIZE];
      36              : } Ctrl_Packet;
      37              : 
      38            0 : int connectToDevice(const char *ip, struct sockaddr_in *server_addr) {
      39            0 :     int sockfd;
      40              : 
      41              : #ifdef _WIN32
      42              :     WSADATA wsaData;
      43              :     if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
      44              :         fprintf(stderr, "WSAStartup failed\n");
      45              :         return -1;
      46              :     }
      47              : #endif
      48              : 
      49            0 :     sockfd = socket(AF_INET, SOCK_DGRAM, 0);
      50            0 :     if (sockfd < 0) {
      51            0 :         perror("Socket creation failed");
      52            0 :         return -1;
      53              :     }
      54              : 
      55            0 :     struct timeval timeout;
      56            0 :     timeout.tv_sec = TIMEOUT_SEC;
      57            0 :     timeout.tv_usec = 0;
      58              : 
      59            0 :     setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof(timeout));
      60            0 :     setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, (const char*)&timeout, sizeof(timeout));
      61              : 
      62            0 :     server_addr->sin_family = AF_INET;
      63            0 :     server_addr->sin_port = htons(PORT);
      64            0 :     inet_pton(AF_INET, ip, &server_addr->sin_addr);
      65              : 
      66            0 :     return sockfd;
      67              : }
      68              : 
      69            0 : void disconnectDevice(int sockfd) {
      70            0 :     close(sockfd);
      71              : #ifdef _WIN32
      72              :     WSACleanup();
      73              : #endif
      74            0 : }
      75              : 
      76            0 : int sendReceive(int sockfd, struct sockaddr_in *server_addr, Ctrl_Packet *tx, Ctrl_Packet *rx) {
      77            0 :     socklen_t addr_len = sizeof(*server_addr);
      78            0 :     for (int attempt = 0; attempt < RETRY_COUNT; ++attempt) {
      79            0 :         if (sendto(sockfd, (const char*)tx, tx->header.total_pkt_len, 0, (struct sockaddr*)server_addr, addr_len) < 0) {
      80            0 :             perror("Send failed");
      81            0 :             continue;
      82              :         }
      83              : 
      84            0 :         if (recvfrom(sockfd, (char*)rx, sizeof(Ctrl_Packet), 0, (struct sockaddr*)server_addr, &addr_len) < 0) {
      85            0 :             perror("Receive failed");
      86            0 :             continue;
      87              :         }
      88              : 
      89              :         return 0;
      90              :     }
      91              :     return -1;
      92              : }
      93              : 
      94            0 : int DeviceRead(int sockfd, struct sockaddr_in *server_addr, unsigned int address, unsigned int *value) {
      95            0 :     Ctrl_Packet tx, rx;
      96            0 :     tx.header.total_pkt_len = sizeof(Ctrl_Header);
      97            0 :     tx.header.address = address;
      98            0 :     tx.header.command = 0x01; // Assuming cmdRead is 0x01
      99            0 :     tx.header.size = 1;
     100            0 :     tx.header.status = 0;
     101              : 
     102            0 :     if (sendReceive(sockfd, server_addr, &tx, &rx) != 0) {
     103              :         return -1;
     104              :     }
     105              : 
     106            0 :     if (tx.header.address != rx.header.address) {
     107              :         return -1;
     108              :     }
     109              : 
     110            0 :     *value = rx.data[0];
     111            0 :     return 0;
     112              : }
     113              : 
     114            0 : int main(int argc, char *argv[]) {
     115            0 :     if (argc != 3) {
     116            0 :         fprintf(stderr, "Usage: %s <device_ip> <address>\n", argv[0]);
     117            0 :         return EXIT_FAILURE;
     118              :     }
     119              : 
     120            0 :     const char *device_ip = argv[1];
     121            0 :     unsigned int address = strtoul(argv[2], NULL, 16); // Convert address from hexadecimal
     122              : 
     123            0 :     unsigned int value;
     124            0 :     struct sockaddr_in server_addr;
     125              : 
     126            0 :     int sockfd = connectToDevice(device_ip, &server_addr);
     127            0 :     if (sockfd < 0) {
     128              :         return EXIT_FAILURE;
     129              :     }
     130              : 
     131            0 :     if (DeviceRead(sockfd, &server_addr, address, &value) == 0) {
     132            0 :         printf("Read value: 0x%08X\n", value);
     133              :     } else {
     134            0 :         fprintf(stderr, "Failed to read from device\n");
     135              :     }
     136              : 
     137            0 :     disconnectDevice(sockfd);
     138              :     return EXIT_SUCCESS;
     139              : }