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