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));
}
