hardware/cem-dt-885x/protocol.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <string.h>
  21 #include "protocol.h"
  22
  23 /* Length of expected payload for each token. */
  24 static int token_payloads[][2] = {
  25         { TOKEN_WEIGHT_TIME_FAST, 0 },
  26         { TOKEN_WEIGHT_TIME_SLOW, 0 },
  27         { TOKEN_HOLD_MAX, 0 },
  28         { TOKEN_HOLD_MIN, 0 },
  29         { TOKEN_TIME, 3 },
  30         { TOKEN_MEAS_RANGE_OVER, 0 },
  31         { TOKEN_MEAS_RANGE_UNDER, 0 },
  32         { TOKEN_STORE_FULL, 0 },
  33         { TOKEN_RECORDING_ON, 0 },
  34         { TOKEN_MEAS_WAS_READOUT, 1 },
  35         { TOKEN_MEAS_WAS_BARGRAPH, 0 },
  36         { TOKEN_MEASUREMENT, 2 },
  37         { TOKEN_HOLD_NONE, 0 },
  38         { TOKEN_BATTERY_LOW, 0 },
  39         { TOKEN_MEAS_RANGE_OK, 0 },
  40         { TOKEN_STORE_OK, 0 },
  41         { TOKEN_RECORDING_OFF, 0 },
  42         { TOKEN_WEIGHT_FREQ_A, 1 },
  43         { TOKEN_WEIGHT_FREQ_C, 1 },
  44         { TOKEN_BATTERY_OK, 0 },
  45         { TOKEN_MEAS_RANGE_30_80, 0 },
  46         { TOKEN_MEAS_RANGE_30_130, 0 },
  47         { TOKEN_MEAS_RANGE_50_100, 0 },
  48         { TOKEN_MEAS_RANGE_80_130, 0 },
  49 };
  50
  51 static int find_token_payload_len(unsigned char c)
  52 {
  53         unsigned int i;
  54
  55         for (i = 0; i < ARRAY_SIZE(token_payloads); i++) {
  56                 if (token_payloads[i][0] == c)
  57                         return token_payloads[i][1];
  58         }
  59
  60         return -1;
  61 }
  62
  63 /* Process measurement or setting (0xa5 command). */
  64 static void process_mset(const struct sr_dev_inst *sdi)
  65 {
  66         struct dev_context *devc;
  67         struct sr_datafeed_packet packet;
  68         struct sr_datafeed_analog analog;
  69         GString *dbg;
  70         float fvalue;
  71         int i;
  72
  73         devc = sdi->priv;
  74         if (sr_log_loglevel_get() >= SR_LOG_SPEW) {
  75                 dbg = g_string_sized_new(128);
  76                 g_string_printf(dbg, "got command 0x%.2x token 0x%.2x",
  77                                 devc->cmd, devc->token);
  78                 if (devc->buf_len) {
  79                         g_string_append_printf(dbg, " payload");
  80                         for (i = 0; i < devc->buf_len; i++)
  81                                 g_string_append_printf(dbg, " %.2x", devc->buf[i]);
  82                 }
  83                 sr_spew("%s", dbg->str);
  84                 g_string_free(dbg, TRUE);
  85         }
  86
  87         switch(devc->token) {
  88         case TOKEN_WEIGHT_TIME_FAST:
  89                 devc->cur_mqflags |= SR_MQFLAG_SPL_TIME_WEIGHT_F;
  90                 devc->cur_mqflags &= ~SR_MQFLAG_SPL_TIME_WEIGHT_S;
  91                 break;
  92         case TOKEN_WEIGHT_TIME_SLOW:
  93                 devc->cur_mqflags |= SR_MQFLAG_SPL_TIME_WEIGHT_S;
  94                 devc->cur_mqflags &= ~SR_MQFLAG_SPL_TIME_WEIGHT_F;
  95                 break;
  96         case TOKEN_WEIGHT_FREQ_A:
  97                 devc->cur_mqflags |= SR_MQFLAG_SPL_FREQ_WEIGHT_A;
  98                 devc->cur_mqflags &= ~SR_MQFLAG_SPL_FREQ_WEIGHT_C;
  99                 break;
 100         case TOKEN_WEIGHT_FREQ_C:
 101                 devc->cur_mqflags |= SR_MQFLAG_SPL_FREQ_WEIGHT_C;
 102                 devc->cur_mqflags &= ~SR_MQFLAG_SPL_FREQ_WEIGHT_A;
 103                 break;
 104         case TOKEN_HOLD_MAX:
 105                 devc->cur_mqflags |= SR_MQFLAG_HOLD | SR_MQFLAG_MAX;
 106                 devc->cur_mqflags &= ~SR_MQFLAG_MIN;
 107                 break;
 108         case TOKEN_HOLD_MIN:
 109                 devc->cur_mqflags |= SR_MQFLAG_HOLD | SR_MQFLAG_MIN;
 110                 devc->cur_mqflags &= ~SR_MQFLAG_MAX;
 111                 break;
 112         case TOKEN_HOLD_NONE:
 113                 devc->cur_mqflags &= ~(SR_MQFLAG_MAX | SR_MQFLAG_MIN | SR_MQFLAG_HOLD);
 114                 break;
 115         case TOKEN_MEASUREMENT:
 116                 fvalue = ((devc->buf[0] & 0xf0) >> 4) * 100;
 117                 fvalue += (devc->buf[0] & 0x0f) * 10;
 118                 fvalue += ((devc->buf[1] & 0xf0) >> 4);
 119                 fvalue += (devc->buf[1] & 0x0f) / 10.0;
 120                 devc->last_spl = fvalue;
 121                 break;
 122         case TOKEN_MEAS_WAS_READOUT:
 123         case TOKEN_MEAS_WAS_BARGRAPH:
 124                 if (devc->cur_mqflags & (SR_MQFLAG_MAX | SR_MQFLAG_MIN)) {
 125                         if (devc->token == TOKEN_MEAS_WAS_BARGRAPH) {
 126                                 /* The device still sends bargraph measurements even
 127                                  * when in max/min hold mode. Suppress them here, unless
 128                                  * they're readout values. This duplicates the behavior
 129                                  * of the device display exactly. */
 130                                 break;
 131                         }
 132                 }
 133                 memset(&analog, 0, sizeof(struct sr_datafeed_analog));
 134                 analog.mq = SR_MQ_SOUND_PRESSURE_LEVEL;
 135                 analog.mqflags = devc->cur_mqflags;
 136                 analog.unit = SR_UNIT_DECIBEL_SPL;
 137                 analog.probes = sdi->probes;
 138                 analog.num_samples = 1;
 139                 analog.data = &devc->last_spl;
 140                 packet.type = SR_DF_ANALOG;
 141                 packet.payload = &analog;
 142                 sr_session_send(devc->cb_data, &packet);
 143
 144                 devc->num_samples++;
 145                 if (devc->limit_samples && devc->num_samples >= devc->limit_samples)
 146                         sdi->driver->dev_acquisition_stop((struct sr_dev_inst *)sdi,
 147                                         devc->cb_data);
 148                 break;
 149         case TOKEN_TIME:
 150         case TOKEN_STORE_OK:
 151         case TOKEN_STORE_FULL:
 152         case TOKEN_RECORDING_ON:
 153         case TOKEN_RECORDING_OFF:
 154         case TOKEN_BATTERY_OK:
 155         case TOKEN_BATTERY_LOW:
 156         case TOKEN_MEAS_RANGE_OK:
 157         case TOKEN_MEAS_RANGE_OVER:
 158         case TOKEN_MEAS_RANGE_UNDER:
 159         case TOKEN_MEAS_RANGE_30_80:
 160         case TOKEN_MEAS_RANGE_30_130:
 161         case TOKEN_MEAS_RANGE_50_100:
 162         case TOKEN_MEAS_RANGE_80_130:
 163                 /* Not useful, or not expressable in sigrok. */
 164                 break;
 165         }
 166
 167 }
 168
 169 static void process_byte(const struct sr_dev_inst *sdi, const unsigned char c)
 170 {
 171         struct dev_context *devc;
 172         gint64 cur_time;
 173         int len;
 174
 175         if (!(devc = sdi->priv))
 176                 return;
 177
 178         if (c == 0xff) {
 179                 /* Device is in hold mode */
 180                 devc->cur_mqflags |= SR_MQFLAG_HOLD;
 181
 182                 if (devc->hold_last_sent == 0) {
 183                         /* First hold notification. */
 184                         devc->hold_last_sent = g_get_monotonic_time();
 185                         /* When the device leaves hold mode, it starts from scratch. */
 186                         devc->state = ST_INIT;
 187                 } else {
 188                         cur_time = g_get_monotonic_time();
 189                         if (cur_time - devc->hold_last_sent > HOLD_REPEAT_INTERVAL) {
 190                                 /* Force the last measurement out again. */
 191                                 devc->cmd = 0xa5;
 192                                 devc->token = TOKEN_MEAS_WAS_READOUT;
 193                                 process_mset(sdi);
 194                                 devc->hold_last_sent = cur_time;
 195                         }
 196                 }
 197
 198                 return;
 199         }
 200         devc->cur_mqflags &= ~SR_MQFLAG_HOLD;
 201         devc->hold_last_sent = 0;
 202
 203         if (devc->state == ST_INIT) {
 204                 if (c == 0xa5) {
 205                         devc->cmd = c;
 206                         devc->token = 0x00;
 207                         devc->state = ST_GET_TOKEN;
 208                 } else if (c == 0xbb) {
 209                         devc->cmd = c;
 210                         devc->buf_len = 0;
 211                         devc->state = ST_GET_LOG;
 212                 }
 213         } else if (devc->state == ST_GET_TOKEN) {
 214                 devc->token = c;
 215                 devc->buf_len = 0;
 216                 len = find_token_payload_len(devc->token);
 217                 if (len == -1 || len > 0) {
 218                         devc->buf_len = 0;
 219                         devc->state = ST_GET_DATA;
 220                 } else {
 221                         process_mset(sdi);
 222                         devc->state = ST_INIT;
 223                 }
 224         } else if (devc->state == ST_GET_DATA) {
 225                 len = find_token_payload_len(devc->token);
 226                 if (len == -1) {
 227                         /* We don't know this token. */
 228                         sr_dbg("Unknown 0xa5 token 0x%.2x", devc->token);
 229                         if (c == 0xa5 || c == 0xbb) {
 230                                 /* Looks like a new command however. */
 231                                 process_mset(sdi);
 232                                 devc->state = ST_INIT;
 233                         } else {
 234                                 devc->buf[devc->buf_len++] = c;
 235                                 if (devc->buf_len > BUF_SIZE) {
 236                                         /* Shouldn't happen, ignore. */
 237                                         devc->state = ST_INIT;
 238                                 }
 239                         }
 240                 } else {
 241                         devc->buf[devc->buf_len++] = c;
 242                         if (devc->buf_len == len) {
 243                                 process_mset(sdi);
 244                                 devc->state = ST_INIT;
 245                         } else if (devc->buf_len > BUF_SIZE) {
 246                                 /* Shouldn't happen, ignore. */
 247                                 devc->state = ST_INIT;
 248                         }
 249                 }
 250         } else if (devc->state == ST_GET_LOG) {
 251         }
 252
 253 }
 254
 255 SR_PRIV int cem_dt_885x_receive_data(int fd, int revents, void *cb_data)
 256 {
 257         const struct sr_dev_inst *sdi;
 258         struct sr_serial_dev_inst *serial;
 259         unsigned char c;
 260
 261         (void)fd;
 262
 263         if (!(sdi = cb_data))
 264                 return TRUE;
 265
 266         serial = sdi->conn;
 267         if (revents == G_IO_IN) {
 268                 if (serial_read(serial, &c, 1) != 1)
 269                         return TRUE;
 270                 process_byte(sdi, c);
 271         }
 272
 273         return TRUE;
 274 }