git.itanic.dy.fi Git - glucose/blob - main.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4 #include <linux/types.h>
   5 #include <linux/hiddev.h>
   6 #include <string.h>
   7 #include <errno.h>
   8 #include <time.h>
   9
  10 #include "hiddev.h"
  11 #include "utils.h"
  12
  13
  14 struct msg {
  15         int direction;
  16         unsigned char data[64];
  17 };
  18
  19 enum direction {
  20         IN = 666,
  21         OUT,
  22 };
  23
  24 int send_msg(const struct msg *msg, int fd, int usage_code)
  25 {
  26         int ret;
  27
  28         if (msg->direction != OUT) {
  29                 trace(0, "Message direction is not OUT\n");
  30                 exit(1);
  31         }
  32
  33         usleep(30 * 1000);
  34         trace(1, "Sending: ");
  35         if (trace_level >= 3)
  36                 print_hex(msg->data + 1, datalen(msg->data) - 1);
  37         if (trace_level >= 2)
  38                 print_ascii(msg->data + 1, datalen(msg->data) - 1);
  39
  40         ret = hiddev_write(msg->data, fd, usage_code);
  41         if (ret)
  42                 exit(1);
  43
  44         return 0;
  45 }
  46
  47 int read_and_verify(struct msg *msg, int fd)
  48 {
  49         unsigned char buf[64];
  50         int ret, offset = 0;
  51
  52         while (offset < 64) {
  53                 ret = hiddev_read(buf + offset, sizeof(buf) - offset, fd);
  54
  55                 if (ret < 0)
  56                         goto err;
  57
  58                 offset += ret;
  59         }
  60
  61         memcpy(msg->data, buf, sizeof(buf));
  62         trace(2, "Got data %d: ", datalen(buf));
  63         if (trace_level >= 3)
  64                 print_hex(buf, datalen(buf));
  65         if (trace_level >= 2)
  66                 print_ascii(buf, datalen(buf));
  67 err:
  68         return 0;
  69 }
  70
  71 int read_msgs(int fd)
  72 {
  73         struct msg msg;
  74         while (1) {
  75                 read_and_verify(&msg, fd);
  76                 if (datalen(msg.data) <= 36)
  77                         break;
  78         }
  79
  80         return 0;
  81 }
  82
  83 #define SET_FIRST_BYTE(byte)                                    \
  84         do {                                                    \
  85                 memset(&msg.data, 0, sizeof(msg.data));         \
  86                 msg.data[4] = (byte);                           \
  87                 j = 5;                                          \
  88         } while (0)
  89
  90 #define SET_BYTE(idx, byte)                     \
  91         do {                                    \
  92                 msg.data[(idx) + 4] = (byte);   \
  93                 j = (idx) + 1;                  \
  94         } while (0)
  95
  96 #define SET_BYTES(byte) msg.data[j++] = (byte)
  97
  98 int send_pattern(int fd, int uc, unsigned char byte1, unsigned char byte2)
  99 {
 100         int j;
 101         struct msg msg;
 102         msg.direction = OUT;
 103
 104         usleep(100 * 1000);
 105         SET_FIRST_BYTE(0x01);
 106         SET_BYTES(0x04);
 107         send_msg(&msg, fd, uc);
 108         read_msgs(fd);
 109
 110         usleep(250 * 1000);
 111         SET_BYTE(1, 0x15);
 112         send_msg(&msg, fd, uc);
 113         read_msgs(fd);
 114
 115         usleep(100 * 1000);
 116         SET_BYTE(1, 0x05);
 117         send_msg(&msg, fd, uc);
 118         read_msgs(fd);
 119
 120         SET_FIRST_BYTE(0x02);
 121         SET_BYTES(byte1);
 122         SET_BYTES('|');
 123         send_msg(&msg, fd, uc);
 124         read_msgs(fd);
 125
 126         usleep(100 * 1000);
 127         SET_BYTE(1, byte2);
 128         send_msg(&msg, fd, uc);
 129         read_msgs(fd);
 130
 131         return 0;
 132 }
 133
 134 int communicate(int fd, int uc)
 135 {
 136         int i, j;
 137         struct msg msg, in;
 138         msg.direction = OUT;
 139
 140         read_msgs(fd);
 141         SET_FIRST_BYTE(0x01);
 142         SET_BYTES(0x04);
 143         send_msg(&msg, fd, uc);
 144
 145         usleep(100 * 1000);
 146         SET_BYTE(1, 0x06);
 147         send_msg(&msg, fd, uc);
 148         read_msgs(fd);
 149
 150         SET_BYTE(1, 0x15);
 151         for (i = 0; i < 6; i++) {
 152                 usleep(100 * 1000);
 153                 send_msg(&msg, fd, uc);
 154                 read_msgs(fd);
 155         }
 156         usleep(1000 * 1000);
 157         read_msgs(fd);
 158         send_msg(&msg, fd, uc);
 159         read_msgs(fd);
 160
 161         usleep(100 * 1000);
 162         SET_BYTE(1, 0x05);
 163         send_msg(&msg, fd, uc);
 164         read_msgs(fd);
 165
 166         send_pattern(fd, uc, 'R', 'A');
 167         send_pattern(fd, uc, 'R', 'C');
 168         send_pattern(fd, uc, 'R', 'D');
 169         send_pattern(fd, uc, 'R', 'G');
 170         send_pattern(fd, uc, 'R', 'I');
 171         send_pattern(fd, uc, 'R', 'M');
 172         send_pattern(fd, uc, 'R', 'P');
 173         send_pattern(fd, uc, 'R', 'R');
 174         send_pattern(fd, uc, 'R', 'S');
 175         send_pattern(fd, uc, 'R', 'T');
 176         send_pattern(fd, uc, 'R', 'U');
 177         send_pattern(fd, uc, 'R', 'V');
 178         send_pattern(fd, uc, 'R', 'W');
 179         send_pattern(fd, uc, 'R', 'X');
 180         send_pattern(fd, uc, 'W', 'K');
 181
 182         usleep(100 * 1000);
 183         SET_FIRST_BYTE(0x08);
 184         SET_BYTES('O');
 185         SET_BYTES('b');
 186         SET_BYTES('p');
 187         SET_BYTES('s');
 188         SET_BYTES('e');
 189         SET_BYTES('c');
 190         SET_BYTES('3');
 191         SET_BYTES('|');
 192         send_msg(&msg, fd, uc);
 193         read_msgs(fd);
 194
 195         usleep(410 * 1000);
 196         SET_FIRST_BYTE(0x02);
 197         SET_BYTES('R');
 198         SET_BYTES('|');
 199         send_msg(&msg, fd, uc);
 200         read_msgs(fd);
 201
 202         usleep(100 * 1000);
 203         SET_BYTE(1, 'Y');
 204         send_msg(&msg, fd, uc);
 205         read_msgs(fd);
 206
 207         usleep(100 * 1000);
 208         SET_BYTE(1, 'W');
 209         send_msg(&msg, fd, uc);
 210         read_msgs(fd);
 211
 212         usleep(100 * 1000);
 213         SET_BYTE(1, 'K');
 214         send_msg(&msg, fd, uc);
 215         read_msgs(fd);
 216
 217         usleep(100 * 1000);
 218         SET_BYTE(1, 'C');
 219         send_msg(&msg, fd, uc);
 220         read_msgs(fd);
 221
 222         send_pattern(fd, uc, 'R', 'Z');
 223
 224         usleep(100 * 1000);
 225         SET_FIRST_BYTE(0x01);
 226         SET_BYTES(0x04);
 227         send_msg(&msg, fd, uc);
 228         read_msgs(fd);
 229
 230         usleep(100 * 1000);
 231         SET_BYTE(1, 0x15);
 232         send_msg(&msg, fd, uc);
 233         read_msgs(fd);
 234
 235         usleep(100 * 1000);
 236         SET_BYTE(1, 0x05);
 237         send_msg(&msg, fd, uc);
 238         read_msgs(fd);
 239
 240         usleep(100 * 1000);
 241         SET_BYTE(1, 0x04);
 242         send_msg(&msg, fd, uc);
 243         read_msgs(fd);
 244
 245         usleep(100 * 1000);
 246         send_msg(&msg, fd, uc);
 247         read_msgs(fd);
 248
 249         usleep(100 * 1000);
 250         SET_BYTE(1, 0x06);
 251         send_msg(&msg, fd, uc);
 252         read_msgs(fd);
 253
 254         usleep(100 * 1000);
 255         send_msg(&msg, fd, uc);
 256         read_msgs(fd);
 257
 258         usleep(100 * 1000);
 259         send_msg(&msg, fd, uc);
 260         read_msgs(fd);
 261
 262         trace(0, "Glucose readings:\n");
 263         usleep(100 * 1000);
 264         do {
 265                 send_msg(&msg, fd, uc);
 266                 read_and_verify(&in, fd);
 267                 print_ascii(in.data, datalen(in.data));
 268         } while (datalen(in.data) > 45);
 269
 270         return 0;
 271 }
 272
 273 int main(int argc, char *argv[])
 274 {
 275         int fd, usage_code;
 276
 277         fd = hiddev_open(argv[1], &usage_code);
 278         if (fd < 0)
 279                 return 1;
 280
 281         communicate(fd, usage_code);
 282
 283         return 0;
 284 }