trinket.c

   1 /*-------------------------------------------------------------------------
   2  * trinket.c
   3  *
   4  * Copyright (c) 2016, Teodor Sigaev <teodor@sigaev.ru>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *-------------------------------------------------------------------------
  27  */
  28
  29 #include <assert.h>
  30 #include <stdint.h>
  31 #include <stdio.h>
  32 #include <hidapi/hidapi.h>
  33 #include <trinket.h>
  34
  35 #define  packed_struct __attribute__((packed))
  36
  37 typedef enum {
  38         CMD_PING = 0,
  39         CMD_VCC_VALUE = 1,
  40         CMD_VCC_ALARM = 2,
  41         CMD_CLICK_DELAY = 3,
  42         CMD_ALARM_LEVELS = 4,
  43         CMD_RTC = 5,
  44         CMD_DAY_ARCH = 6,
  45         CMD_YEAR_ARCH = 7,
  46         CMD_CUM_DOSE = 8,
  47         CMD_INVOKE_BSL = 9
  48 } TrinketCommand;
  49
  50 #define BEGIN_COMMAND   (0x1B)
  51 #define END_COMMAND             (0x17)
  52 #define ACK_ANSWER_OK   (0x06)
  53 #define ACK_ANSWER_ERR  (0x15)
  54 #define END_ANSWER              (0x17)
  55
  56 /* http://uglyduck.ath.cx/PDF/TexasInstruments/MSP430/usblib430/Programmers_Guide_MSP430_USB_API.pdf */
  57 #define REPORT_ID               (0x3f)
  58 typedef struct packed_struct {
  59         uint8_t reportId;
  60         uint8_t size;
  61 } ProtoHeader;
  62
  63
  64 #define DEV_TIMEOUT             (5000 /* milliseconds */)
  65 typedef struct {
  66         /*
  67          * Command desc
  68          */
  69         uint8_t                 cmdId;
  70         uint8_t                 cmdLen; /* 0 means variable, > 0 fixed */
  71
  72         /*
  73          * Answer desc
  74          */
  75         uint32_t                respLen; /* 0 means variable, > 0 fixed */
  76 } TrinketProtoDesc;
  77
  78 /* hardcoded knowledge from  docs/geyger.pdf */
  79 static const TrinketProtoDesc protoDesc[] = {
  80         {CMD_PING,                      4,              5                               },
  81         {CMD_VCC_VALUE,         4,              8                               },
  82         {CMD_VCC_ALARM,         8,              8                               },
  83         {CMD_CLICK_DELAY,       8,              8                               },
  84         {CMD_ALARM_LEVELS,      24,             24                              },
  85         {CMD_RTC,                       13,             13                              },
  86         {CMD_DAY_ARCH,          4,              4 + 1440 * 2    },
  87         {CMD_YEAR_ARCH,         4,              4 + 5840 * 2    },
  88         {CMD_CUM_DOSE,          4,              12                              },
  89         {CMD_INVOKE_BSL,        4,              0                               }
  90 };
  91
  92 static hid_device *trinketDev = NULL;
  93
  94 #if 0
  95 static void
  96 dumpBuf(char *msg, uint8_t *buf, int len) {
  97         int i;
  98
  99         fprintf(stderr,"%s:", msg);
 100         for (i=0; i<len; i++)
 101                 fprintf(stderr, " %02x", buf[i]);
 102         fprintf(stderr, "\n");
 103 }
 104 #endif
 105
 106 TrinketErrorCode
 107 trinketOpen() {
 108 #ifndef NDEBUG
 109         int i;
 110
 111         for(i = 0; i < sizeof(protoDesc) / sizeof(*protoDesc); i++)
 112                 assert(i == protoDesc[i].cmdId);
 113 #endif
 114
 115         trinketDev = hid_open(0x2047, 0x0301, NULL);
 116
 117         if (trinketDev == NULL) {
 118                 fprintf(stderr, "hid_open fails\n");
 119                 return ERR_ERROR;
 120         }
 121
 122         return trinketPing();
 123 }
 124
 125 void
 126 trinketClose() {
 127         if (trinketDev)
 128                 hid_close(trinketDev);
 129         trinketDev = NULL;
 130 }
 131
 132 TrinketErrorCode
 133 trinketPing() {
 134         const TrinketProtoDesc  *proto = &protoDesc[CMD_PING];
 135         struct packed_struct {
 136                 ProtoHeader header;
 137                 uint8_t         begin;
 138                 uint8_t         len;
 139                 uint8_t         cmd;
 140                 uint8_t         end;
 141         } cmd = {
 142                                         {REPORT_ID, proto->cmdLen},
 143                                         BEGIN_COMMAND,
 144                                         proto->cmdLen,
 145                                         proto->cmdId,
 146                                         END_COMMAND
 147         };
 148         struct packed_struct {
 149                 ProtoHeader header;
 150                 uint8_t         begin;
 151                 uint16_t        len;
 152                 uint8_t         payload /* = 0 */;
 153                 uint8_t         end;
 154         } resp;
 155         int     r;
 156
 157         assert(proto->cmdId == CMD_PING);
 158         assert(sizeof(cmd) == cmd.len + sizeof(ProtoHeader));
 159         assert(sizeof(resp) == proto->respLen + sizeof(ProtoHeader));
 160
 161         r = hid_write(trinketDev, (unsigned char*)&cmd, sizeof(cmd));
 162
 163         if (r < 0 || r != sizeof(cmd)) {
 164                 fprintf(stderr, "hid_write  returns %d instead of %u\n", r, cmd.len);
 165                 return ERR_ERROR;
 166         }
 167
 168         /* must be assigned to 0x3F by the host */
 169         resp.header.reportId = REPORT_ID;
 170
 171         r = hid_read_timeout(trinketDev, (unsigned char*)&resp, sizeof(resp), DEV_TIMEOUT);
 172         if (r < 0) {
 173                 fprintf(stderr, "hid_read_timeout fails\n");
 174                 return  ERR_NO_ANSWER;
 175         }
 176
 177         if (r != sizeof(resp)) {
 178                 fprintf(stderr, "hid_read_timeout  returns %d instead of %u\n", r, (unsigned int)sizeof(resp));
 179                 return ERR_ERROR;
 180         }
 181
 182         if (resp.header.reportId != REPORT_ID) {
 183                 fprintf(stderr, "hid_read_timeout  returns report id %02x instead of %02x\n", resp.header.reportId, REPORT_ID);
 184                 return ERR_ERROR;
 185         }
 186
 187         if (resp.header.size != proto->respLen) {
 188                 fprintf(stderr, "hid_read_timeout returns length %u intsead if %u\n", resp.header.size, proto->respLen);
 189                 return ERR_PROTO;
 190         }
 191
 192         if (resp.len != proto->respLen) {
 193                 fprintf(stderr, "hid_read_timeout response length %u instead of %u\n", resp.len, proto->respLen);
 194                 return ERR_PROTO;
 195         }
 196
 197         if (!(resp.begin == ACK_ANSWER_OK && resp.payload == 0 && resp.end == END_ANSWER)) {
 198                 fprintf(stderr, "hid_read_timeout  ACK %02x with payload %u and ETB %02x\n", resp.begin, resp.payload, resp.end);
 199                 return ERR_PROTO;
 200         }
 201
 202         return ERR_OK;
 203 }
 204
 205 TrinketErrorCode
 206 trinketGetCumDose(double *value) {
 207         const TrinketProtoDesc  *proto = &protoDesc[CMD_CUM_DOSE];
 208         struct {
 209                 ProtoHeader header;
 210                 uint8_t         begin;
 211                 uint8_t         len;
 212                 uint8_t         cmd;
 213                 uint8_t         end;
 214         } cmd = {
 215                                         {REPORT_ID, proto->cmdLen},
 216                                         BEGIN_COMMAND,
 217                                         proto->cmdLen,
 218                                         proto->cmdId,
 219                                         END_COMMAND
 220         };
 221         struct packed_struct {
 222                 ProtoHeader header;
 223                 uint8_t         begin;
 224                 uint16_t        len;
 225                 double          payload;
 226                 uint8_t         end;
 227         } resp;
 228         int     r;
 229
 230         assert(proto->cmdId == CMD_CUM_DOSE);
 231         assert(sizeof(cmd) == cmd.len + sizeof(ProtoHeader));
 232         assert(sizeof(resp) == proto->respLen + sizeof(ProtoHeader));
 233
 234         r = hid_write(trinketDev, (unsigned char*)&cmd, sizeof(cmd));
 235
 236         if (r < 0 || r != sizeof(cmd)) {
 237                 fprintf(stderr, "hid_send_feature_report  returns %d instead of %u\n", r, cmd.len);
 238                 return ERR_ERROR;
 239         }
 240
 241         /* must be assigned to 0x3F by the host */
 242         resp.header.reportId = REPORT_ID;
 243
 244         r = hid_read_timeout(trinketDev, (unsigned char*)&resp, sizeof(resp), DEV_TIMEOUT);
 245         if (r < 0) {
 246                 fprintf(stderr, "hid_read_timeout fails\n");
 247                 return  ERR_NO_ANSWER;
 248         }
 249
 250         if (r != sizeof(resp)) {
 251                 fprintf(stderr, "hid_read_timeout  returns %d instead of %u\n", r, (unsigned int)sizeof(resp));
 252                 return ERR_ERROR;
 253         }
 254
 255         if (resp.header.reportId != REPORT_ID) {
 256                 fprintf(stderr, "hid_read_timeout  returns report id %02x instead of %02x\n", resp.header.reportId, REPORT_ID);
 257                 return ERR_ERROR;
 258         }
 259
 260         if (resp.header.size != proto->respLen) {
 261                 fprintf(stderr, "hid_read_timeout returns length %u intsead if %u\n", resp.header.size, proto->respLen);
 262                 return ERR_PROTO;
 263         }
 264
 265         if (resp.len != proto->respLen) {
 266                 fprintf(stderr, "hid_read_timeout response length %u instead of %u\n", resp.len, proto->respLen);
 267                 return ERR_PROTO;
 268         }
 269
 270         if (!(resp.begin == ACK_ANSWER_OK && resp.end == END_ANSWER)) {
 271                 fprintf(stderr, "hid_read_timeout  ACK %02x and ETB %02x\n", resp.begin, resp.end);
 272                 return ERR_PROTO;
 273         }
 274
 275         *value = resp.payload;
 276
 277         return ERR_OK;
 278 }