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 static const TrinketProtoDesc protoDesc[] = {
  79         {CMD_PING,                      4,              5                               },
  80         {CMD_VCC_VALUE,         4,              8                               },
  81         {CMD_VCC_ALARM,         8,              8                               },
  82         {CMD_CLICK_DELAY,       8,              8                               },
  83         {CMD_ALARM_LEVELS,      24,             24                              },
  84         {CMD_RTC,                       13,             13                              },
  85         {CMD_DAY_ARCH,          4,              4 + 1440 * 2    },
  86         {CMD_YEAR_ARCH,         4,              4 + 5840 * 2    },
  87         {CMD_CUM_DOSE,          4,              12                              },
  88         {CMD_INVOKE_BSL,        4,              0                               }
  89 };
  90
  91 static hid_device *trinketDev = NULL;
  92
  93 #if 0
  94 static void
  95 dumpBuf(char *msg, uint8_t *buf, int len) {
  96         int i;
  97
  98         fprintf(stderr,"%s:", msg);
  99         for (i=0; i<len; i++)
 100                 fprintf(stderr, " %02x", buf[i]);
 101         fprintf(stderr, "\n");
 102 }
 103 #endif
 104
 105 TrinketErrorCode
 106 trinketOpen() {
 107 #ifndef NDEBUG
 108         int i;
 109
 110         for(i = 0; i < sizeof(protoDesc) / sizeof(*protoDesc); i++)
 111                 assert(i == protoDesc[i].cmdId);
 112 #endif
 113
 114         trinketDev = hid_open(0x2047, 0x0301, NULL);
 115
 116         if (trinketDev == NULL) {
 117                 fprintf(stderr, "hid_open fails\n");
 118                 return ERR_ERROR;
 119         }
 120
 121         return trinketPing();
 122 }
 123
 124 void
 125 trinketClose() {
 126         if (trinketDev)
 127                 hid_close(trinketDev);
 128         trinketDev = NULL;
 129 }
 130
 131 TrinketErrorCode
 132 trinketPing() {
 133         const TrinketProtoDesc  *proto = &protoDesc[CMD_PING];
 134         struct packed_struct {
 135                 ProtoHeader header;
 136                 uint8_t         begin;
 137                 uint8_t         len;
 138                 uint8_t         cmd;
 139                 uint8_t         end;
 140         } cmd = {
 141                                         {REPORT_ID, proto->cmdLen},
 142                                         BEGIN_COMMAND,
 143                                         proto->cmdLen,
 144                                         proto->cmdId,
 145                                         END_COMMAND
 146         };
 147         struct packed_struct {
 148                 ProtoHeader header;
 149                 uint8_t         begin;
 150                 uint16_t        len;
 151                 uint8_t         payload /* = 0 */;
 152                 uint8_t         end;
 153         } resp;
 154         int     r;
 155
 156         assert(proto->cmdId == CMD_PING);
 157         assert(sizeof(cmd) == cmd.len + sizeof(ProtoHeader));
 158         assert(sizeof(resp) == proto->respLen + sizeof(ProtoHeader));
 159
 160         r = hid_write(trinketDev, (unsigned char*)&cmd, sizeof(cmd));
 161
 162         if (r < 0 || r != sizeof(cmd)) {
 163                 fprintf(stderr, "hid_write  returns %d instead of %u\n", r, cmd.len);
 164                 return ERR_ERROR;
 165         }
 166
 167         /* must be assigned to 0x3F by the host */
 168         resp.header.reportId = REPORT_ID;
 169
 170         r = hid_read_timeout(trinketDev, (unsigned char*)&resp, sizeof(resp), DEV_TIMEOUT);
 171         if (r < 0) {
 172                 fprintf(stderr, "hid_read_timeout fails\n");
 173                 return  ERR_NO_ANSWER;
 174         }
 175
 176         if (r != sizeof(resp)) {
 177                 fprintf(stderr, "hid_read_timeout  returns %d instead of %u\n", r, (unsigned int)sizeof(resp));
 178                 return ERR_ERROR;
 179         }
 180
 181         if (resp.header.reportId != REPORT_ID) {
 182                 fprintf(stderr, "hid_read_timeout  returns report id %02x instead of %02x\n", resp.header.reportId, REPORT_ID);
 183                 return ERR_ERROR;
 184         }
 185
 186         if (resp.header.size != proto->respLen) {
 187                 fprintf(stderr, "hid_read_timeout returns length %u intsead if %u\n", resp.header.size, proto->respLen);
 188                 return ERR_PROTO;
 189         }
 190
 191         if (resp.len != proto->respLen) {
 192                 fprintf(stderr, "hid_read_timeout response length %u instead of %u\n", resp.len, proto->respLen);
 193                 return ERR_PROTO;
 194         }
 195
 196         if (!(resp.begin == ACK_ANSWER_OK && resp.payload == 0 && resp.end == END_ANSWER)) {
 197                 fprintf(stderr, "hid_read_timeout  ACK %02x with payload %u and ETB %02x\n", resp.begin, resp.payload, resp.end);
 198                 return ERR_PROTO;
 199         }
 200
 201         return ERR_OK;
 202 }
 203
 204 TrinketErrorCode
 205 trinketGetCumDose(double *value) {
 206         const TrinketProtoDesc  *proto = &protoDesc[CMD_CUM_DOSE];
 207         struct {
 208                 ProtoHeader header;
 209                 uint8_t         begin;
 210                 uint8_t         len;
 211                 uint8_t         cmd;
 212                 uint8_t         end;
 213         } cmd = {
 214                                         {REPORT_ID, proto->cmdLen},
 215                                         BEGIN_COMMAND,
 216                                         proto->cmdLen,
 217                                         proto->cmdId,
 218                                         END_COMMAND
 219         };
 220         struct packed_struct {
 221                 ProtoHeader header;
 222                 uint8_t         begin;
 223                 uint16_t        len;
 224                 double          payload;
 225                 uint8_t         end;
 226         } resp;
 227         int     r;
 228
 229         assert(proto->cmdId == CMD_CUM_DOSE);
 230         assert(sizeof(cmd) == cmd.len + sizeof(ProtoHeader));
 231         assert(sizeof(resp) == proto->respLen + sizeof(ProtoHeader));
 232
 233         r = hid_write(trinketDev, (unsigned char*)&cmd, sizeof(cmd));
 234
 235         if (r < 0 || r != sizeof(cmd)) {
 236                 fprintf(stderr, "hid_send_feature_report  returns %d instead of %u\n", r, cmd.len);
 237                 return ERR_ERROR;
 238         }
 239
 240         /* must be assigned to 0x3F by the host */
 241         resp.header.reportId = REPORT_ID;
 242
 243         r = hid_read_timeout(trinketDev, (unsigned char*)&resp, sizeof(resp), DEV_TIMEOUT);
 244         if (r < 0) {
 245                 fprintf(stderr, "hid_read_timeout fails\n");
 246                 return  ERR_NO_ANSWER;
 247         }
 248
 249         if (r != sizeof(resp)) {
 250                 fprintf(stderr, "hid_read_timeout  returns %d instead of %u\n", r, (unsigned int)sizeof(resp));
 251                 return ERR_ERROR;
 252         }
 253
 254         if (resp.header.reportId != REPORT_ID) {
 255                 fprintf(stderr, "hid_read_timeout  returns report id %02x instead of %02x\n", resp.header.reportId, REPORT_ID);
 256                 return ERR_ERROR;
 257         }
 258
 259         if (resp.header.size != proto->respLen) {
 260                 fprintf(stderr, "hid_read_timeout returns length %u intsead if %u\n", resp.header.size, proto->respLen);
 261                 return ERR_PROTO;
 262         }
 263
 264         if (resp.len != proto->respLen) {
 265                 fprintf(stderr, "hid_read_timeout response length %u instead of %u\n", resp.len, proto->respLen);
 266                 return ERR_PROTO;
 267         }
 268
 269         if (!(resp.begin == ACK_ANSWER_OK && resp.end == END_ANSWER)) {
 270                 fprintf(stderr, "hid_read_timeout  ACK %02x and ETB %02x\n", resp.begin, resp.end);
 271                 return ERR_PROTO;
 272         }
 273
 274         *value = resp.payload;
 275
 276         return ERR_OK;
 277 }