#include <glib.h>
#include <sigrok.h>
+#ifdef _WIN32
+#define O_NONBLOCK FIONBIO
+#endif
+
#define NUM_PROBES 32
#define NUM_TRIGGER_STAGES 4
#define TRIGGER_TYPES "01"
#define SERIAL_SPEED B115200
-/* TODO: SERIAL_ bits, parity, stop bit */
#define CLOCK_RATE 100000000
/* Command opcodes */
{
char buf[1];
- g_message("ols: sending cmd 0x%.2x", command);
+ g_debug("ols: sending cmd 0x%.2x", command);
buf[0] = command;
- if (write(fd, buf, 1) != 1)
+ if (serial_write(fd, buf, 1) != 1)
return SIGROK_ERR;
return SIGROK_OK;
{
char buf[5];
- g_message("ols: sending cmd 0x%.2x data 0x%.8x", command, data);
+ g_debug("ols: sending cmd 0x%.2x data 0x%.8x", command, data);
buf[0] = command;
buf[1] = (data & 0xff000000) >> 24;
buf[2] = (data & 0xff0000) >> 16;
buf[3] = (data & 0xff00) >> 8;
buf[4] = data & 0xff;
- if (write(fd, buf, 5) != 5)
+ if (serial_write(fd, buf, 5) != 5)
return SIGROK_ERR;
return SIGROK_OK;
* we do all the sending first, then wait for all of them to
* respond with g_poll().
*/
- g_message("probing %s...", (char *)l->data);
-#ifdef _WIN32
- // FIXME
- // hdl = serial_open(l->data, 0);
-#else
+ g_message("ols: probing %s...", (char *)l->data);
fd = serial_open(l->data, O_RDWR | O_NONBLOCK);
-#endif
if (fd != -1) {
serial_params[devcnt] = serial_backup_params(fd);
serial_set_params(fd, 115200, 8, 0, 1, 2);
g_poll(fds, devcnt, 1);
for (i = 0; i < devcnt; i++) {
if (fds[i].revents == G_IO_IN) {
- if (read(fds[i].fd, buf, 4) == 4) {
+ if (serial_read(fds[i].fd, buf, 4) == 4) {
if (!strncmp(buf, "1SLO", 4)
|| !strncmp(buf, "1ALS", 4)) {
if (!strncmp(buf, "1SLO", 4))
else
sdi = sigrok_device_instance_new
(final_devcnt, ST_INACTIVE,
- "Sump", "Logic Analyzer",
+ "Openbench", "Logic Sniffer",
"v1.0");
sdi->serial = serial_device_instance_new
(device_names[i], -1);
divider = (CLOCK_RATE / samplerate) - 1;
}
- g_message("setting samplerate to %" PRIu64 " Hz (divider %u, demux %s)",
+ g_message("ols: setting samplerate to %" PRIu64 " Hz (divider %u, demux %s)",
samplerate, divider, flag_reg & FLAG_DEMUX ? "on" : "off");
if (send_longcommand(sdi->serial->fd, CMD_SET_DIVIDER, reverse32(divider)) != SIGROK_OK)
case HWCAP_LIMIT_SAMPLES:
tmp_u64 = value;
limit_samples = *tmp_u64;
+ g_message("ols: sample limit %" PRIu64, limit_samples);
ret = SIGROK_OK;
break;
case HWCAP_CAPTURE_RATIO:
if (revents == G_IO_IN
&& num_transfers / num_channels <= limit_samples) {
- if (read(fd, &byte, 1) != 1)
+ if (serial_read(fd, &byte, 1) != 1)
return FALSE;
sample[num_bytes++] = byte;
-// g_message("received byte 0x%.2x", byte);
+ g_debug("ols: received byte 0x%.2x", byte);
if (num_bytes == num_channels) {
-// g_message("received sample 0x%.*x", num_bytes * 2, (int) *sample);
+ g_debug("ols: received sample 0x%.*x", num_bytes * 2, (int) *sample);
/* Got a full sample. */
if (flag_reg & FLAG_RLE) {
/*
}
}
memcpy(sample, tmp_sample, 4);
-// g_message("full sample 0x%.8x", (int) *sample);
+ g_debug("ols: full sample 0x%.8x", (int) *sample);
}
/* the OLS sends its sample buffer backwards.
* store it in reverse order here, so we can dump
* this on the session bus later.
*/
- offset = (limit_samples - num_transfers) * 4;
+ offset = (limit_samples - num_transfers / num_channels) * 4;
memcpy(raw_sample_buf + offset, sample, 4);
-// /* Send it all to the session bus. */
-// packet.type = DF_LOGIC32;
-// packet.length = buflen;
-// packet.payload = buffer;
-// session_bus(user_data, &packet);
-
if (buffer == sample)
memcpy(last_sample, buffer, num_channels);
else
*/
if (trigger_at > 0) {
/* there are pre-trigger samples, send those first */
- packet.type = DF_LOGIC32;
+ packet.type = DF_LOGIC;
packet.length = trigger_at * 4;
+ packet.unitsize = 4;
packet.payload = raw_sample_buf;
session_bus(user_data, &packet);
}
packet.length = 0;
session_bus(user_data, &packet);
- packet.type = DF_LOGIC32;
+ packet.type = DF_LOGIC;
packet.length = (limit_samples * 4) - (trigger_at * 4);
+ packet.unitsize = 4;
packet.payload = raw_sample_buf + trigger_at * 4;
session_bus(user_data, &packet);
} else {
- packet.type = DF_LOGIC32;
+ packet.type = DF_LOGIC;
packet.length = limit_samples * 4;
+ packet.unitsize = 4;
packet.payload = raw_sample_buf;
session_bus(user_data, &packet);
}
free(raw_sample_buf);
-#ifndef _WIN32
- /* TODO: Move to serial.c? */
- tcflush(fd, TCIOFLUSH);
-#endif
+ serial_flush(fd);
serial_close(fd);
packet.type = DF_END;
packet.length = 0;
if (trigger_mask[0]) {
delaycount = readcount * (1 - capture_ratio / 100.0);
trigger_at = (readcount - delaycount) * 4 - num_stages;
- g_message("ta %d", trigger_at);
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_0,
reverse32(trigger_mask[0])) != SIGROK_OK)
if (probe_mask & (0xff << (i * 8)))
changrp_mask |= (1 << i);
}
- g_message("changrp_mask 0x%.2x", changrp_mask);
/* The flag register wants them here, and 1 means "disable channel". */
flag_reg |= ~(changrp_mask << 2) & 0x3c;
- g_message("flag_reg 0x%.2x", flag_reg & 0x3c);
-
flag_reg |= FLAG_FILTER;
data = flag_reg << 24;
if (send_longcommand(sdi->serial->fd, CMD_SET_FLAGS, data) != SIGROK_OK)
gettimeofday(&header->starttime, NULL);
header->samplerate = cur_samplerate;
header->protocol_id = PROTO_RAW;
- header->num_probes = NUM_PROBES;
+ header->num_logic_probes = NUM_PROBES;
+ header->num_analog_probes = 0;
session_bus(session_device_id, packet);
g_free(header);
g_free(packet);
{
struct datafeed_packet packet;
- /* QUICK HACK */
+ /* Avoid compiler warnings. */
device_index = device_index;
packet.type = DF_END;
}
struct device_plugin ols_plugin_info = {
- "sump",
+ "ols",
1,
hw_init,
hw_cleanup,
projects / libsigrok.git / blobdiff