static int dev_acquisition_start(const struct sr_dev_inst *sdi) { int ret; struct dev_context *devc; struct sr_serial_dev_inst *serial; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; devc = sdi->priv; serial = sdi->conn; /* Send the 'monitor <ms>' command (doesn't have a reply). */ if ((ret = serial_write_blocking(serial, CMD_MONITOR, strlen(CMD_MONITOR), serial_timeout(serial, strlen(CMD_MONITOR)))) < (int)strlen(CMD_MONITOR)) { sr_err("Unable to send 'monitor' command: %d.", ret); return SR_ERR; } /* Poll every 100ms, or whenever some data comes in. */ serial_source_add(sdi->session, serial, G_IO_IN, 100, reloadpro_receive_data, (void *)sdi); sr_sw_limits_acquisition_start(&devc->limits); std_session_send_df_header(sdi); memset(devc->buf, 0, RELOADPRO_BUFSIZE); devc->buflen = 0; return SR_OK; }
static int nma_send_req(const struct sr_dev_inst *sdi, int req, char *params) { struct sr_serial_dev_inst *serial; struct dev_context *devc; char buf[NMADMM_BUFSIZE]; int len; if (!sdi || !(serial = sdi->conn) || !(devc = sdi->priv)) return SR_ERR_BUG; len = snprintf(buf, sizeof(buf), "%s%s\r\n", nmadmm_requests[req].req_str, params ? params : ""); sr_spew("Sending request: '%s'.", buf); devc->last_req = req; devc->last_req_pending = TRUE; if (serial_write_blocking(serial, buf, len, serial_timeout(serial, len)) < 0) { sr_err("Unable to send request."); devc->last_req_pending = FALSE; return SR_ERR; } devc->req_sent_at = g_get_monotonic_time(); return SR_OK; }
/** * Send command with parameter. * * @param[in] cmd Command * @param[in] param Parameter (0..999, depending on command). * * @retval SR_OK Success. * @retval SR_ERR_ARG Invalid argument. * @retval SR_ERR Error. */ SR_PRIV int send_msg1(const struct sr_dev_inst *sdi, char cmd, int param) { struct sr_serial_dev_inst *serial; char buf[5]; if (!sdi || !(serial = sdi->conn)) return SR_ERR_ARG; snprintf(buf, sizeof(buf), "%c%03d", cmd, param); buf[4] = '\r'; sr_spew("send_msg1(): %c%c%c%c\\r", buf[0], buf[1], buf[2], buf[3]); if (serial_write_blocking(serial, buf, sizeof(buf), serial_timeout(serial, sizeof(buf))) < (int)sizeof(buf)) { sr_err("Write error for cmd=%c", cmd); return SR_ERR; } /* * Wait 50ms to ensure that the device does not swallow any of the * following commands. */ g_usleep(50 * 1000); return SR_OK; }
static int mic_send(struct sr_serial_dev_inst *serial, const char *cmd) { int ret; if ((ret = serial_write_blocking(serial, cmd, strlen(cmd), serial_timeout(serial, strlen(cmd)))) < 0) { sr_err("Error sending '%s' command: %d.", cmd, ret); return SR_ERR; } return SR_OK; }
/** Send command to device with va_list. */ SR_PRIV int lps_send_va(struct sr_serial_dev_inst *serial, const char *fmt, va_list args) { int retc; char auxfmt[LINELEN_MAX]; char buf[LINELEN_MAX]; snprintf(auxfmt, sizeof(auxfmt), "%s\r\n", fmt); vsnprintf(buf, sizeof(buf), auxfmt, args); sr_spew("lps_send_va: \"%s\"", buf); retc = serial_write_blocking(serial, buf, strlen(buf), serial_timeout(serial, strlen(buf))); if (retc < 0) return SR_ERR; return SR_OK; }
SR_PRIV int hcs_send_cmd(struct sr_serial_dev_inst *serial, const char *cmd, ...) { int ret; char cmdbuf[50]; char *cmd_esc; va_list args; va_start(args, cmd); vsnprintf(cmdbuf, sizeof(cmdbuf), cmd, args); va_end(args); cmd_esc = g_strescape(cmdbuf, NULL); sr_dbg("Sending '%s'.", cmd_esc); g_free(cmd_esc); if ((ret = serial_write_blocking(serial, cmdbuf, strlen(cmdbuf), serial_timeout(serial, strlen(cmdbuf)))) < 0) { sr_err("Error sending command: %d.", ret); return ret; } return ret; }
static GSList *scan(struct sr_dev_driver *di, GSList *options) { struct sr_dev_inst *sdi; struct dev_context *devc; struct sr_config *src; struct sr_serial_dev_inst *serial; struct sr_channel_group *cg; struct sr_channel *ch; GSList *l; int ret, len; const char *conn, *serialcomm; char buf[100]; char *bufptr; double version; conn = serialcomm = NULL; for (l = options; l; l = l->next) { src = l->data; switch (src->key) { case SR_CONF_CONN: conn = g_variant_get_string(src->data, NULL); break; case SR_CONF_SERIALCOMM: serialcomm = g_variant_get_string(src->data, NULL); break; } } if (!conn) return NULL; if (!serialcomm) serialcomm = SERIALCOMM; serial = sr_serial_dev_inst_new(conn, serialcomm); if (serial_open(serial, SERIAL_RDWR) != SR_OK) return NULL; serial_flush(serial); if (serial_write_blocking(serial, CMD_VERSION, strlen(CMD_VERSION), serial_timeout(serial, strlen(CMD_VERSION))) < (int)strlen(CMD_VERSION)) { sr_dbg("Unable to write while probing for hardware."); serial_close(serial); return NULL; } memset(buf, 0, sizeof(buf)); bufptr = buf; len = sizeof(buf); ret = serial_readline(serial, &bufptr, &len, 3000); if (ret < 0 || len < 9 || strncmp((const char *)&buf, "version ", 8)) { sr_dbg("Unable to probe version number."); serial_close(serial); return NULL; } version = g_ascii_strtod(buf + 8, NULL); if (version < 1.10) { sr_info("Firmware >= 1.10 required (got %1.2f).", version); serial_close(serial); return NULL; } sdi = g_malloc0(sizeof(struct sr_dev_inst)); sdi->status = SR_ST_INACTIVE; sdi->vendor = g_strdup("Arachnid Labs"); sdi->model = g_strdup("Re:load Pro"); sdi->version = g_strdup(buf + 8); sdi->inst_type = SR_INST_SERIAL; sdi->conn = serial; cg = g_malloc0(sizeof(struct sr_channel_group)); cg->name = g_strdup("1"); sdi->channel_groups = g_slist_append(sdi->channel_groups, cg); ch = sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "V"); cg->channels = g_slist_append(cg->channels, ch); ch = sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "I"); cg->channels = g_slist_append(cg->channels, ch); devc = g_malloc0(sizeof(struct dev_context)); sr_sw_limits_init(&devc->limits); sdi->priv = devc; serial_close(serial); return std_scan_complete(di, g_slist_append(NULL, sdi)); }