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