src/visomat-data-downloader.c

   1 /*
   2  * visomat-data-downloader - download data from Visomat Double Comfort
   3  *
   4  * The Visomat Double Comfort is a blood pressure meter with a USB port.
   5  *
   6  * Copyright (C) 2013  Antonio Ospite <ospite@studenti.unina.it>
   7  *
   8  * This program is free software: you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation, either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <unistd.h>
  27 #include <libusb.h>
  28
  29 #define VISOMAT_DEVICE_VID    0x1247
  30 #define VISOMAT_DEVICE_PID    0x00f8
  31 #define VISOMAT_CONFIGURATION 1
  32 #define VISOMAT_INTERFACE     1
  33 #define VISOMAT_EP_IN         0x82
  34 #define VISOMAT_EP_OUT        0x03
  35
  36 #define STX 0x02
  37 #define ETX 0x03
  38
  39 #define BASE_YEAR 2000
  40
  41 typedef enum {
  42         VISOMAT_CMD_DUMP_EEPROM,
  43         VISOMAT_CMD_UNKNOWN1, /* maybe the firmware revision */
  44         VISOMAT_CMD_GET_DATETIME,
  45         VISOMAT_CMD_START_MEASURE1,
  46         VISOMAT_CMD_UNKNOWN2, /* XXX transmission hangs */
  47         VISOMAT_CMD_UNKNOWN3,
  48 } visomat_command;
  49
  50 static char command_codes[][3] = {
  51         [VISOMAT_CMD_DUMP_EEPROM]    = "R00",
  52         [VISOMAT_CMD_UNKNOWN1]       = "R01",
  53         [VISOMAT_CMD_GET_DATETIME]   = "R02",
  54         [VISOMAT_CMD_START_MEASURE1] = "R03",
  55         [VISOMAT_CMD_UNKNOWN2]       = "R04",
  56         [VISOMAT_CMD_UNKNOWN3]       = "R05",
  57 };
  58
  59 struct datetime  {
  60         unsigned int year;
  61         unsigned int month;
  62         unsigned int day;
  63         unsigned int hour;
  64         unsigned int minute;
  65 };
  66
  67 struct pressure  {
  68         unsigned int flag; /* XXX Maybe this means arrhythmia? */
  69         unsigned int systolic;
  70         unsigned int diastolic;
  71         unsigned int pulses;
  72 };
  73
  74 static inline int extract_datetime(unsigned char *buffer, struct datetime *d)
  75 {
  76         int ret;
  77
  78         ret = sscanf((char *)buffer, "%02u%02u%02u%02u%02u",
  79                      &d->year,
  80                      &d->month,
  81                      &d->day,
  82                      &d->hour,
  83                      &d->minute);
  84         if (ret != 5)
  85                 return -EINVAL;
  86
  87         d->year += BASE_YEAR;
  88
  89         return 0;
  90 }
  91
  92 /*
  93  * NOTE: the CSV output is meant to be compatible with one from the Windows
  94  * program, which uses the %d/%m/%Y date format, so that's not my fault.
  95  */
  96 static void print_record_csv_compat(struct datetime *d, struct pressure *p)
  97 {
  98         unsigned int pulse_pressure;
  99
 100         printf("%02u/%02u/%04u;%02u.%02u;",
 101                d->day, d->month, d->year, d->hour, d->minute);
 102
 103         printf("%u;%u;%u;", p->systolic, p->diastolic, p->pulses);
 104
 105         pulse_pressure = p->systolic - p->diastolic;
 106         printf("%u;", pulse_pressure);
 107
 108         if (p->flag)
 109                 printf("x");
 110
 111 #if 0
 112         /* The original software does not seem to be doing that */
 113         if (p->pulses > 100)
 114                 printf("tachycardia");
 115         else if (p->pulses < 60)
 116                 printf("bradycardia");
 117 #endif
 118
 119         printf("\n");
 120 }
 121
 122 /* TODO: it would be better to separate decoding data from printing it */
 123 static int decode_eeprom(unsigned char *buffer,
 124                          unsigned int len,
 125                          unsigned int user_mask)
 126 {
 127         int ret;
 128         unsigned int n;
 129         unsigned int i;
 130         unsigned int j;
 131         unsigned int user_id;
 132         unsigned int num_records;
 133         struct datetime d;
 134         struct pressure p;
 135
 136         if (buffer[0] != STX || buffer[1] != 'M' || buffer[len - 1] != ETX)
 137                 return -EINVAL;
 138
 139         /* skip the initial STX */
 140         i = 1;
 141
 142         /* and the final ETX */
 143         n = len - 1;
 144
 145         while (i < n) {
 146                 /* Each user record begins with 'M', maybe for "Memory" */
 147                 if (buffer[i] == 'M') {
 148                         /* i tracks the bytes consumed */
 149                         i += 1;
 150
 151                         ret = sscanf((char *)(buffer + i), "%1u%02u",
 152                                      &user_id, &num_records);
 153                         if (ret != 2)
 154                                 return -EINVAL;
 155
 156                         /* user_id and num_records take 3 bytes */
 157                         i += 3;
 158
 159                         /*
 160                          * when there are no records, there is a dummy byte
 161                          * which has to be consumed
 162                          */
 163                         if (num_records == 0)
 164                                 i += 1;
 165
 166                         for (j = 0; j < num_records; j++) {
 167                                 ret = extract_datetime(buffer + i, &d);
 168                                 if (ret < 0)
 169                                         return ret;
 170
 171                                 /* datetime takes 10 bytes */
 172                                 i += 10;
 173
 174                                 ret = sscanf((char *)(buffer + i),
 175                                              "%1u%03u%03u%03u",
 176                                              &p.flag,
 177                                              &p.systolic,
 178                                              &p.diastolic,
 179                                              &p.pulses);
 180                                 if (ret != 4)
 181                                         return -EINVAL;
 182
 183                                 /* pressure data is 10 bytes */
 184                                 i += 10;
 185
 186                                 /* TODO: split out the printing part */
 187                                 if (user_id & user_mask) {
 188                                         if (j == 0)
 189                                                 printf("# User: %d\n", user_id);
 190                                         print_record_csv_compat(&d, &p);
 191                                 }
 192                         }
 193                 }
 194         }
 195
 196         return 0;
 197 }
 198
 199 static int decode_datetime(unsigned char *buffer, unsigned int len)
 200 {
 201         int ret;
 202         unsigned char code[4] = { 0 };
 203         struct datetime d;
 204         unsigned char *pbuffer = buffer;
 205
 206         if (len != 15)
 207                 return -EINVAL;
 208
 209         code[0] = buffer[1];
 210         code[1] = buffer[2];
 211         code[2] = buffer[3];
 212
 213         ret = extract_datetime(pbuffer + 4, &d);
 214         if (ret < 0)
 215                 return ret;
 216
 217         printf("# (%s) Date: %04d/%02d/%02d %02d:%02d\n",
 218                code, d.year, d.month, d.day, d.hour, d.minute);
 219
 220         return 0;
 221 }
 222
 223 static int send_command(libusb_device_handle *dev, visomat_command cmd)
 224 {
 225         int ret;
 226         int transferred;
 227         unsigned char request[5];
 228
 229         request[0] = STX;
 230         request[1] = command_codes[cmd][0];
 231         request[2] = command_codes[cmd][1];
 232         request[3] = command_codes[cmd][2];
 233         request[4] = ETX;
 234
 235         transferred = 0;
 236         ret = libusb_bulk_transfer(dev, VISOMAT_EP_OUT, request, sizeof(request), &transferred, 0);
 237         if (ret != 0 || transferred != sizeof(request)) {
 238                 fprintf(stderr, "Error: sending request: %d (%s)\ttransferred: %d (expected %zu)\n",
 239                         ret, libusb_error_name(ret), transferred, sizeof(request));
 240                 return ret;
 241         }
 242         return 0;
 243 }
 244
 245 static int get_response(libusb_device_handle *dev,
 246                         unsigned char *buffer,
 247                         unsigned int len)
 248 {
 249         int ret;
 250         int transferred;
 251         unsigned char response[64] = { 0 };
 252         unsigned int i;
 253
 254         i = 0;
 255         do {
 256                 unsigned int j;
 257
 258                 transferred = 0;
 259                 ret = libusb_bulk_transfer(dev, VISOMAT_EP_IN, response, sizeof(response), &transferred, 5000);
 260                 if (ret != 0) {
 261                         fprintf(stderr, "Error getting response: %d (%s)\ttransferred: %d (expected %zu)\n",
 262                                 ret, libusb_error_name(ret), transferred, sizeof(response));
 263                         return ret;
 264                 }
 265
 266                 for (j = 0; j < (unsigned int)transferred; j++) {
 267                         buffer[i] = response[j];
 268                         i += 1;
 269                 }
 270
 271         } while (buffer[i - 1] != ETX && i < len);
 272
 273         /* Check the buffer is a valid response packet */
 274         if (buffer[0] != STX || buffer[i - 1] != ETX)
 275                 return -EINVAL;
 276
 277         return i;
 278 }
 279
 280 /* Candidates for a future public API, if a shared library will ever be made */
 281 #define visomat_device libusb_device_handle
 282 static int visomat_dump_eeprom(visomat_device *dev, unsigned int user_mask)
 283 {
 284         /* Assuming an EEPROM of 1 KiB  */
 285         unsigned char buffer[1024] = { 0 };
 286         int ret;
 287
 288         ret = send_command(dev, VISOMAT_CMD_DUMP_EEPROM);
 289         if (ret < 0)
 290                 return ret;
 291
 292         ret = get_response(dev, buffer, sizeof(buffer));
 293         if (ret < 0)
 294                 return ret;
 295
 296         ret = decode_eeprom(buffer, ret, user_mask);
 297         if (ret < 0)
 298                 return ret;
 299
 300         return 0;
 301 }
 302
 303 static int visomat_get_datetime(visomat_device *dev)
 304 {
 305         unsigned char buffer[255] = { 0 };
 306         int ret;
 307
 308         ret = send_command(dev, VISOMAT_CMD_GET_DATETIME);
 309         if (ret < 0)
 310                 return ret;
 311
 312         ret = get_response(dev, buffer, sizeof(buffer));
 313         if (ret < 0)
 314                 return ret;
 315
 316         ret = decode_datetime(buffer, ret);
 317         if (ret < 0)
 318                 return ret;
 319
 320         return 0;
 321 }
 322
 323 int main(void)
 324 {
 325         int ret;
 326         libusb_device_handle *dev;
 327         int current_configuration;
 328
 329         ret = libusb_init(NULL);
 330         if (ret < 0) {
 331                 fprintf(stderr, "libusb_init failed: %s\n",
 332                         libusb_error_name(ret));
 333                 goto out;
 334         }
 335
 336         libusb_set_debug(NULL, LIBUSB_LOG_LEVEL_INFO);
 337
 338         dev = libusb_open_device_with_vid_pid(NULL,
 339                                               VISOMAT_DEVICE_VID,
 340                                               VISOMAT_DEVICE_PID);
 341         if (dev == NULL) {
 342                 fprintf(stderr, "libusb_open failed: %s\n", strerror(errno));
 343                 ret = -errno;
 344                 goto out_libusb_exit;
 345         }
 346
 347         current_configuration = -1;
 348         ret = libusb_get_configuration(dev, &current_configuration);
 349         if (ret < 0) {
 350                 fprintf(stderr, "libusb_get_configuration failed: %s\n",
 351                         libusb_error_name(ret));
 352                 goto out_libusb_close;
 353         }
 354
 355         if (current_configuration != VISOMAT_CONFIGURATION) {
 356                 ret = libusb_set_configuration(dev, VISOMAT_CONFIGURATION);
 357                 if (ret < 0) {
 358                         fprintf(stderr, "libusb_set_configuration failed: %s\n",
 359                                 libusb_error_name(ret));
 360                         fprintf(stderr, "Cannot set configuration %d\n",
 361                                 VISOMAT_CONFIGURATION);
 362                         goto out_libusb_close;
 363                 }
 364         }
 365
 366         libusb_set_auto_detach_kernel_driver(dev, 1);
 367
 368         ret = libusb_claim_interface(dev, VISOMAT_INTERFACE);
 369         if (ret < 0) {
 370                 fprintf(stderr, "libusb_claim_interface failed: %s\n",
 371                         libusb_error_name(ret));
 372                 fprintf(stderr, "Cannot claim interface %d\n",
 373                         VISOMAT_INTERFACE);
 374                 goto out_libusb_close;
 375         }
 376
 377         /* Checking that the configuration has not changed, as suggested in
 378          * http://libusb.sourceforge.net/api-1.0/caveats.html
 379          */
 380         current_configuration = -1;
 381         ret = libusb_get_configuration(dev, &current_configuration);
 382         if (ret < 0) {
 383                 fprintf(stderr, "libusb_get_configuration after claim failed: %s\n",
 384                         libusb_error_name(ret));
 385                 goto out_libusb_release_interface;
 386         }
 387
 388         if (current_configuration != VISOMAT_CONFIGURATION) {
 389                 fprintf(stderr, "libusb configuration changed (expected: %d, current: %d\n",
 390                         VISOMAT_CONFIGURATION, current_configuration);
 391                 ret = -EINVAL;
 392                 goto out_libusb_release_interface;
 393         }
 394
 395         ret = visomat_get_datetime(dev);
 396         if (ret < 0)
 397                 goto out_libusb_release_interface;
 398
 399         ret = visomat_dump_eeprom(dev, 0x01 | 0x02);
 400         if (ret < 0)
 401                 goto out_libusb_release_interface;
 402
 403 out_libusb_release_interface:
 404         libusb_release_interface(dev, VISOMAT_INTERFACE);
 405 out_libusb_close:
 406         libusb_close(dev);
 407         dev = NULL;
 408 out_libusb_exit:
 409         libusb_exit(NULL);
 410 out:
 411         return ret;
 412 }