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