Embedded/DSView
1
0
Fork 0
mirror of https://github.com/DreamSourceLab/DSView.git synced 2025-01-13 13:32:53 +08:00
Code Issues Projects Releases Wiki Activity

Merge pull request #611 from yunyaobaihong/demo

Browse Source 
demo
This commit is contained in:
dreamsourcelabTAI 2023-05-10 14:37:31 +08:00 committed by GitHub
commit b4f430f317
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 259 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

411
libsigrok4DSL/hardware/demo/demo.c
View File

@ -155,6 +155,9 @@ static int get_pattern_mode_index_by_string(uint8_t device_mode , const char* st
i++; i++;
} }
} }
if(index == PATTERN_INVALID)
index = PATTERN_RANDOM;
return index; return index;
} }
@ -226,23 +229,24 @@ static int scan_dsl_file(struct sr_dev_inst *sdi)
char * str = pattern_strings_logic[index]; char * str = pattern_strings_logic[index];
pattern_strings_logic[index] = pattern_strings_logic[PATTERN_DEFAULT]; pattern_strings_logic[index] = pattern_strings_logic[PATTERN_DEFAULT];
pattern_strings_logic[PATTERN_DEFAULT] = str; pattern_strings_logic[PATTERN_DEFAULT] = str;
cur_sample_generator = pre_sample_generator = PATTERN_DEFAULT; sample_generator = PATTERN_DEFAULT;
sdi->mode = LOGIC; sdi->mode = LOGIC;
sdi->path = g_strdup(get_dsl_path_by_pattern_mode(LOGIC,PATTERN_DEFAULT)); reset_dsl_path(sdi,LOGIC,PATTERN_DEFAULT);
} }
else else
{ {
cur_sample_generator = pre_sample_generator = PATTERN_RANDOM; sample_generator = PATTERN_RANDOM;
sdi->mode = LOGIC; sdi->mode = LOGIC;
g_safe_free(sdi->path); reset_dsl_path(sdi,LOGIC,PATTERN_RANDOM);
sdi->path = g_strdup("");
} }
} }
static char* get_dsl_path_by_pattern_mode(uint8_t device_mode , uint8_t pattern_mode) static int reset_dsl_path(struct sr_dev_inst *sdi,uint8_t device_mode ,uint8_t pattern_mode)
{ {
unzFile archive = NULL; unzFile archive = NULL;
if(sdi->path != NULL)
g_safe_free(sdi->path);
char *str = g_try_malloc0(500); char *str = g_try_malloc0(500);
strcpy(str,DS_RES_PATH); strcpy(str,DS_RES_PATH);
strcat(str,"../"); strcat(str,"../");
@ -282,24 +286,27 @@ static char* get_dsl_path_by_pattern_mode(uint8_t device_mode , uint8_t pattern_
if(pattern_mode != PATTERN_RANDOM) if(pattern_mode != PATTERN_RANDOM)
{ {
archive = unzOpen64(str); archive = unzOpen64(str);
if (NULL != archive) if (NULL != archive){
{ sdi->path = str;
return str; return SR_OK;
} }
else else{
{ g_safe_free(str);
return ""; sdi->path = g_strdup("");
return SR_ERR;
} }
} }
else else{
{ g_safe_free(str);
return NULL; sdi->path = g_strdup("");
return SR_OK;
} }
} }
static void adjust_samplerate(struct sr_dev_inst *sdi) static void adjust_samplerate(struct sr_dev_inst *sdi)
{ {
if(sdi->mode == LOGIC && cur_sample_generator > PATTERN_RANDOM) if(sdi->mode == LOGIC && sample_generator > PATTERN_RANDOM)
{ {
return; return;
} }
@ -336,28 +343,46 @@ static void adjust_samplerate(struct sr_dev_inst *sdi)
} }
static int init_random_data(struct session_vdev * vdev) static int init_random_data(struct session_vdev * vdev,struct sr_dev_inst *sdi)
{ {
uint8_t random_val; uint8_t random_val;
if(vdev->logic_buf != NULL) struct sr_channel *probe;
GSList *l = NULL;
int enabled_probe = 0;
int cur_probe = 0;
int probe_count[LOGIC_MAX_PROBE_NUM] = {0};
uint8_t probe_status[LOGIC_MAX_PROBE_NUM] = {LOGIC_HIGH_LEVEL};
memset(probe_status,LOGIC_HIGH_LEVEL,16);
memset(vdev->logic_buf,0,SR_MB(1));
for(int i = 0 ;i < enabled_probe_num;i++)
{ {
g_free(vdev->logic_buf); probe_count[i] = rand()%SR_KB(10);
} }
if(!(vdev->logic_buf = g_try_malloc0(SR_MB(10))))
{
return SR_ERR;
}
vdev->logic_buf_len = SR_MB(10);
for(int i = 0 ; i < vdev->logic_buf_len ;i++) for(int i = 0 ; i < vdev->logic_buf_len ;i++)
{ {
random_val = abs(rand())%256; if(i % 8 == 0 && i != 0)
if(random_val >= 128)
{ {
*(uint8_t*)(vdev->logic_buf + i) = (uint8_t)255; cur_probe++;
if(cur_probe >enabled_probe_num-1)
cur_probe = 0;
}
if(probe_count[cur_probe]> 0)
{
memset(vdev->logic_buf+i,probe_status[cur_probe],1);
probe_count[cur_probe] -= 1;
} }
else else
{ {
*(uint8_t*)(vdev->logic_buf + i) = (uint8_t)0; if(probe_status[cur_probe] == LOGIC_HIGH_LEVEL)
probe_status[cur_probe] = LOGIC_LOW_LEVEL;
else
probe_status[cur_probe] = LOGIC_HIGH_LEVEL;
probe_count[cur_probe] = rand()%SR_KB(10);
memset(vdev->logic_buf+i,probe_status[cur_probe],1);
probe_count[cur_probe] -= 1;
} }
} }
return; return;
@ -465,11 +490,20 @@ static int hw_dev_open(struct sr_dev_inst *sdi)
vdev->logic_buf = NULL; vdev->logic_buf = NULL;
sdi->status = SR_ST_ACTIVE; sdi->status = SR_ST_ACTIVE;
if(vdev->logic_buf != NULL)
{
g_safe_free(vdev->logic_buf);
}
if(!(vdev->logic_buf = g_try_malloc0(SR_MB(1))))
{
return SR_ERR;
}
vdev->logic_buf_len = SR_MB(1);
packet_interval = g_timer_new(); packet_interval = g_timer_new();
run_time = g_timer_new(); run_time = g_timer_new();
init_random_data(vdev);
ret = load_virtual_device_session(sdi); ret = load_virtual_device_session(sdi);
if (ret != SR_OK) if (ret != SR_OK)
{ {
@ -510,9 +544,8 @@ static int hw_dev_close(struct sr_dev_inst *sdi)
g_safe_free(vdev->logic_buf); g_safe_free(vdev->logic_buf);
g_safe_free(vdev->analog_buf); g_safe_free(vdev->analog_buf);
g_safe_free(sdi->path); g_safe_free(sdi->path);
g_safe_free(packet_interval);
// g_timer_destroy(packet_interval); g_safe_free(run_time);
// g_timer_destroy(run_time);
sdi->status = SR_ST_INACTIVE; sdi->status = SR_ST_INACTIVE;
return SR_OK; return SR_OK;
@ -528,8 +561,6 @@ static int dev_destroy(struct sr_dev_inst *sdi)
sr_dev_inst_free(sdi); sr_dev_inst_free(sdi);
} }
static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi, static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel *ch, const struct sr_channel *ch,
const struct sr_channel_group *cg) const struct sr_channel_group *cg)
@ -560,11 +591,11 @@ static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
break; break;
case SR_CONF_PATTERN_MODE: case SR_CONF_PATTERN_MODE:
if(sdi->mode == LOGIC) if(sdi->mode == LOGIC)
*data = g_variant_new_string(pattern_strings_logic[cur_sample_generator]); *data = g_variant_new_string(pattern_strings_logic[sample_generator]);
else if(sdi->mode == DSO) else if(sdi->mode == DSO)
*data = g_variant_new_string(pattern_strings_dso[cur_sample_generator]); *data = g_variant_new_string(pattern_strings_dso[sample_generator]);
else else
*data = g_variant_new_string(pattern_strings_analog[cur_sample_generator]); *data = g_variant_new_string(pattern_strings_analog[sample_generator]);
break; break;
case SR_CONF_MAX_HEIGHT: case SR_CONF_MAX_HEIGHT:
*data = g_variant_new_string(maxHeights[vdev->max_height]); *data = g_variant_new_string(maxHeights[vdev->max_height]);
@ -616,17 +647,22 @@ static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
*data = g_variant_new_uint64(SR_Kn(20)); *data = g_variant_new_uint64(SR_Kn(20));
break; break;
case SR_CONF_HW_DEPTH: case SR_CONF_HW_DEPTH:
if(sdi->mode == DSO || (sdi->mode == LOGIC && cur_sample_generator != PATTERN_RANDOM)) switch (sdi->mode)
{ {
*data = g_variant_new_uint64(vdev->total_samples); case LOGIC:
} if(sample_generator == PATTERN_RANDOM)
else if(sdi->mode == ANALOG) *data = g_variant_new_uint64(LOGIC_HW_DEPTH);
{ else
*data = g_variant_new_uint64(SR_MHZ(12.5)); *data = g_variant_new_uint64(vdev->total_samples);
} break;
else case DSO:
{ *data = g_variant_new_uint64(vdev->total_samples);
*data = g_variant_new_uint64(SR_MHZ(100)); break;
case ANALOG:
*data = g_variant_new_uint64(ANALOG_HW_DEPTH);
break;
default:
break;
} }
break; break;
case SR_CONF_UNIT_BITS: case SR_CONF_UNIT_BITS:
@ -658,7 +694,7 @@ static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
case SR_CONF_HAVE_ZERO: case SR_CONF_HAVE_ZERO:
break; break;
case SR_CONF_LOAD_DECODER: case SR_CONF_LOAD_DECODER:
*data = g_variant_new_boolean(cur_sample_generator != PATTERN_RANDOM); *data = g_variant_new_boolean(sample_generator != PATTERN_RANDOM);
break; break;
case SR_CONF_REF_MIN: case SR_CONF_REF_MIN:
*data = g_variant_new_uint32(vdev->ref_min); *data = g_variant_new_uint32(vdev->ref_min);
@ -692,7 +728,7 @@ static int config_set(int id, GVariant *data, struct sr_dev_inst *sdi,
{ {
case SR_CONF_SAMPLERATE: case SR_CONF_SAMPLERATE:
vdev->samplerate = g_variant_get_uint64(data); vdev->samplerate = g_variant_get_uint64(data);
if(sdi->mode == LOGIC && cur_sample_generator >PATTERN_RANDOM) if(sdi->mode == LOGIC && sample_generator >PATTERN_RANDOM)
{ {
samplerates_file[0] = vdev->samplerate; samplerates_file[0] = vdev->samplerate;
} }
@ -700,7 +736,7 @@ static int config_set(int id, GVariant *data, struct sr_dev_inst *sdi,
break; break;
case SR_CONF_LIMIT_SAMPLES: case SR_CONF_LIMIT_SAMPLES:
vdev->total_samples = g_variant_get_uint64(data); vdev->total_samples = g_variant_get_uint64(data);
if(sdi->mode == LOGIC && cur_sample_generator >PATTERN_RANDOM) if(sdi->mode == LOGIC && sample_generator >PATTERN_RANDOM)
{ {
samplecounts_file[0] = vdev->total_samples; samplecounts_file[0] = vdev->total_samples;
} }
@ -710,31 +746,22 @@ static int config_set(int id, GVariant *data, struct sr_dev_inst *sdi,
break; break;
case SR_CONF_DEVICE_MODE: case SR_CONF_DEVICE_MODE:
sdi->mode = g_variant_get_int16(data); sdi->mode = g_variant_get_int16(data);
if(sdi->path)
switch (sdi->mode) switch (sdi->mode)
{ {
case LOGIC: case LOGIC:
if("" != get_dsl_path_by_pattern_mode(sdi->mode,PATTERN_DEFAULT)) if(SR_OK == reset_dsl_path(sdi,sdi->mode ,PATTERN_DEFAULT))
{ sample_generator = PATTERN_DEFAULT;
cur_sample_generator = pre_sample_generator = PATTERN_DEFAULT;
g_safe_free(sdi->path);
sdi->path = g_strdup(get_dsl_path_by_pattern_mode(sdi->mode,PATTERN_DEFAULT));
}
else else
{ sample_generator = PATTERN_RANDOM;
cur_sample_generator = pre_sample_generator = PATTERN_RANDOM;
g_safe_free(sdi->path);
sdi->path = g_strdup("");
}
break; break;
case DSO: case DSO:
cur_sample_generator = pre_sample_generator = PATTERN_RANDOM; reset_dsl_path(sdi,sdi->mode ,PATTERN_RANDOM);
g_safe_free(sdi->path); sample_generator = PATTERN_RANDOM;
sdi->path = g_strdup(""); break;
case ANALOG: case ANALOG:
cur_sample_generator = pre_sample_generator = PATTERN_RANDOM; reset_dsl_path(sdi,sdi->mode ,PATTERN_RANDOM);
g_safe_free(sdi->path); sample_generator = PATTERN_RANDOM;
sdi->path = g_strdup(""); break;
default: default:
break; break;
} }
@ -742,46 +769,14 @@ static int config_set(int id, GVariant *data, struct sr_dev_inst *sdi,
break; break;
case SR_CONF_PATTERN_MODE: case SR_CONF_PATTERN_MODE:
stropt = g_variant_get_string(data, NULL); stropt = g_variant_get_string(data, NULL);
pre_sample_generator= cur_sample_generator; sample_generator = get_pattern_mode_index_by_string(sdi->mode , stropt);
if(get_pattern_mode_index_by_string(sdi->mode , stropt) != PATTERN_INVALID) if(SR_OK != reset_dsl_path(sdi,sdi->mode,sample_generator))
{ {
switch (sdi->mode) sample_generator = PATTERN_RANDOM;
{
case LOGIC:
cur_sample_generator = get_pattern_mode_index_by_string(sdi->mode , stropt);
break;
case DSO:
cur_sample_generator = get_pattern_mode_index_by_string(sdi->mode , stropt);
break;
case ANALOG:
cur_sample_generator = get_pattern_mode_index_by_string(sdi->mode , stropt);
break;
default:
break;
}
g_safe_free(sdi->path);
sdi->path = get_dsl_path_by_pattern_mode(sdi->mode,cur_sample_generator);
if (sdi->path[0] == 0 &&
cur_sample_generator != PATTERN_RANDOM)
{
cur_sample_generator = pre_sample_generator;
}
}
else
{
cur_sample_generator = pre_sample_generator;
}
if(cur_sample_generator != pre_sample_generator)
{
// is_change = TRUE;
pre_sample_generator = cur_sample_generator;
// load_virtual_device_session(sdi);
} }
sr_dbg("%s: setting pattern to %d", sr_dbg("%s: setting pattern to %d",
__func__, cur_sample_generator); __func__, sample_generator);
break; break;
case SR_CONF_MAX_HEIGHT: case SR_CONF_MAX_HEIGHT:
@ -888,8 +883,8 @@ static int config_set(int id, GVariant *data, struct sr_dev_inst *sdi,
is_change = g_variant_get_boolean(data); is_change = g_variant_get_boolean(data);
break; break;
case SR_CONF_DEMO_INIT: case SR_CONF_DEMO_INIT:
pre_sample_generator = cur_sample_generator;
load_virtual_device_session(sdi); load_virtual_device_session(sdi);
break;
case SR_CONF_LOOP_MODE: case SR_CONF_LOOP_MODE:
vdev->is_loop = g_variant_get_boolean(data); vdev->is_loop = g_variant_get_boolean(data);
sr_info("Set demo loop mode:%d", vdev->is_loop); sr_info("Set demo loop mode:%d", vdev->is_loop);
@ -926,7 +921,7 @@ static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
break; break;
case SR_CONF_SAMPLERATE: case SR_CONF_SAMPLERATE:
g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}")); g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
if(sdi->mode == LOGIC && cur_sample_generator != PATTERN_RANDOM) if(sdi->mode == LOGIC && sample_generator != PATTERN_RANDOM)
{ {
gvar = g_variant_new_from_data(G_VARIANT_TYPE("at"), gvar = g_variant_new_from_data(G_VARIANT_TYPE("at"),
samplerates_file, ARRAY_SIZE(samplerates_file) * sizeof(uint64_t), TRUE, NULL, NULL); samplerates_file, ARRAY_SIZE(samplerates_file) * sizeof(uint64_t), TRUE, NULL, NULL);
@ -1007,7 +1002,7 @@ static int hw_dev_acquisition_start(struct sr_dev_inst *sdi,
vdev->cur_block = 0; vdev->cur_block = 0;
vdev->cur_channel = 0; vdev->cur_channel = 0;
if(cur_sample_generator != PATTERN_RANDOM) if(sample_generator != PATTERN_RANDOM)
{ {
if (vdev->archive != NULL) if (vdev->archive != NULL)
{ {
@ -1055,6 +1050,7 @@ static int hw_dev_acquisition_start(struct sr_dev_inst *sdi,
ds_data_forward(sdi, &packet); ds_data_forward(sdi, &packet);
} }
if(sdi->mode == LOGIC) if(sdi->mode == LOGIC)
{ {
enabled_probe_num = 0; enabled_probe_num = 0;
@ -1066,14 +1062,14 @@ static int hw_dev_acquisition_start(struct sr_dev_inst *sdi,
enabled_probe_num++; enabled_probe_num++;
} }
} }
is_first = TRUE;
post_data_len = 0; post_data_len = 0;
uint64_t post_date_per_second = vdev->samplerate / 8 ; packet_len = POST_DATA_PER_SECOND(vdev->samplerate) / LOGIC_PACKET_NUM_PER_SEC;
packet_len = post_date_per_second / 22; packet_len = LOGIC_PACKET_LEN;
packet_len = floor(packet_len/8)*8; packet_time = SEC / LOGIC_PACKET_NUM_PER_SEC;
packet_time = 1/(double)22; if(sample_generator == PATTERN_RANDOM)
if(cur_sample_generator == PATTERN_RANDOM)
{ {
init_random_data(vdev,sdi);
sr_session_source_add(-1, 0, 0, receive_data_logic, sdi); sr_session_source_add(-1, 0, 0, receive_data_logic, sdi);
} }
else else
@ -1083,18 +1079,18 @@ static int hw_dev_acquisition_start(struct sr_dev_inst *sdi,
} }
else if(sdi->mode == DSO) else if(sdi->mode == DSO)
{ {
is_first = TRUE; load_data = TRUE;
vdiv_change = TRUE; vdiv_change = TRUE;
packet_time = 1/(double)200; packet_time = SEC / DSO_PACKET_NUM_PER_SEC;
g_timer_start(run_time); g_timer_start(run_time);
sr_session_source_add(-1, 0, 0, receive_data_dso, sdi); sr_session_source_add(-1, 0, 0, receive_data_dso, sdi);
} }
else if(sdi->mode == ANALOG) else if(sdi->mode == ANALOG)
{ {
is_first = TRUE; load_data = TRUE;
gdouble total_time = vdev->total_samples/vdev->samplerate; gdouble total_time = vdev->total_samples/(gdouble)vdev->samplerate;
uint64_t post_date_per_second = vdev->total_samples / total_time *2; uint64_t post_date_per_second = vdev->total_samples / total_time *2;
packet_len = post_date_per_second / 22; packet_len = post_date_per_second / 200;
if(packet_len <= 1) if(packet_len <= 1)
{ {
@ -1108,7 +1104,7 @@ static int hw_dev_acquisition_start(struct sr_dev_inst *sdi,
{ {
packet_len += 1; packet_len += 1;
} }
packet_time = 1/(double)22; packet_time = 1/(double)200;
} }
@ -1220,14 +1216,14 @@ static int receive_data_logic(int fd, int revents, const struct sr_dev_inst *sdi
} }
pack_buffer = vdev->packet_buffer; pack_buffer = vdev->packet_buffer;
// Make packet. // Make packet.
read_chan_index = 0; read_chan_index = 0;
dir_index = 0; dir_index = 0;
if(post_data_len >= vdev->total_samples/8) if(!vdev->is_loop){
{ if(post_data_len >= vdev->total_samples/8){
bToEnd = 1; bToEnd = 1;
}
} }
if(!bToEnd) if(!bToEnd)
@ -1239,15 +1235,19 @@ static int receive_data_logic(int fd, int revents, const struct sr_dev_inst *sdi
logic.order = 0; logic.order = 0;
logic.length = chan_num * packet_len; logic.length = chan_num * packet_len;
post_data_len += logic.length / enabled_probe_num; if(!vdev->is_loop){
if(post_data_len >= vdev->total_samples/8) post_data_len += logic.length / enabled_probe_num;
{ if(post_data_len >= vdev->total_samples/8){
int last_packet_len = post_data_len - (logic.length / enabled_probe_num); int last_packet_len = post_data_len - (logic.length / enabled_probe_num);
last_packet_len = (vdev->total_samples/8) - last_packet_len; last_packet_len = (vdev->total_samples/8) - last_packet_len;
logic.length = last_packet_len * enabled_probe_num; logic.length = last_packet_len * enabled_probe_num;
}
} }
uint64_t random = vdev->logic_buf_len - logic.length; uint64_t random = vdev->logic_buf_len - logic.length;
random = abs(rand()) %random; random = rand() % random;
int index = enabled_probe_num * 8;
random = floor(random/index)*index;
logic.data = vdev->logic_buf + random; logic.data = vdev->logic_buf + random;
gdouble packet_elapsed = g_timer_elapsed(packet_interval, NULL); gdouble packet_elapsed = g_timer_elapsed(packet_interval, NULL);
@ -1557,9 +1557,21 @@ static int receive_data_logic_decoder(int fd, int revents, const struct sr_dev_i
return TRUE; return TRUE;
} }
int get_bit(uint64_t timebase)
{
if(timebase < SR_MS(1) && timebase >= SR_US(20))
return SR_MS(1)/timebase*2;
else if(timebase < SR_MS(200) && timebase >= SR_MS(1))
return SR_MS(200)/timebase*2;
else if(timebase <= SR_SEC(10) && timebase > SR_MS(200))
return SR_SEC(40)/timebase*2;
else
return 200;
}
static int receive_data_dso(int fd, int revents, const struct sr_dev_inst *sdi) static int receive_data_dso(int fd, int revents, const struct sr_dev_inst *sdi)
{ {
struct session_vdev *vdev = NULL; struct session_vdev *vdev = NULL;
struct sr_datafeed_packet packet; struct sr_datafeed_packet packet;
struct sr_datafeed_dso dso; struct sr_datafeed_dso dso;
struct sr_channel *probe; struct sr_channel *probe;
@ -1600,7 +1612,7 @@ static int receive_data_dso(int fd, int revents, const struct sr_dev_inst *sdi)
vdev = sdi->priv; vdev = sdi->priv;
assert(vdev->unit_bits > 0); assert(vdev->unit_bits > 0);
if(cur_sample_generator != PATTERN_RANDOM) if(sample_generator != PATTERN_RANDOM)
{ {
assert(vdev->archive); assert(vdev->archive);
} }
@ -1685,9 +1697,9 @@ static int receive_data_dso(int fd, int revents, const struct sr_dev_inst *sdi)
read_chan_index = 0; read_chan_index = 0;
dir_index = 0; dir_index = 0;
if(vdiv_change) if(vdiv_change || timebase_change)
{ {
if(cur_sample_generator == PATTERN_RANDOM) if(sample_generator == PATTERN_RANDOM)
{ {
for(int i = 0 ; i < pack_buffer->post_buf_len ;i++) for(int i = 0 ; i < pack_buffer->post_buf_len ;i++)
{ {
@ -1707,8 +1719,6 @@ static int receive_data_dso(int fd, int revents, const struct sr_dev_inst *sdi)
{ {
if (vdev->cur_block >= vdev->num_blocks){ if (vdev->cur_block >= vdev->num_blocks){
vdev->cur_block = 0; vdev->cur_block = 0;
// bToEnd = 1;
break;
} }
for (ch_index = 0; ch_index < chan_num; ch_index++) for (ch_index = 0; ch_index < chan_num; ch_index++)
@ -1777,23 +1787,23 @@ static int receive_data_dso(int fd, int revents, const struct sr_dev_inst *sdi)
} }
} }
// Read the data to buffer. // Read the data to buffer.
if (unzOpenCurrentFile(vdev->archive) != UNZ_OK) if (unzOpenCurrentFile(vdev->archive) != UNZ_OK)
{ {
sr_err("cant't open zip inner file:\"%s\"", file_name); sr_err("cant't open zip inner file:\"%s\"", file_name);
send_error_packet(sdi, vdev, &packet); send_error_packet(sdi, vdev, &packet);
return FALSE; return FALSE;
} }
ret = unzReadCurrentFile(vdev->archive, pack_buffer->block_bufs[ch_index], pack_buffer->block_data_len); ret = unzReadCurrentFile(vdev->archive, pack_buffer->block_bufs[ch_index], pack_buffer->block_data_len);
if (-1 == ret) if (-1 == ret)
{ {
sr_err("read zip inner file error:\"%s\"", file_name); sr_err("read zip inner file error:\"%s\"", file_name);
send_error_packet(sdi, vdev, &packet); send_error_packet(sdi, vdev, &packet);
return FALSE; return FALSE;
} }
unzCloseCurrentFile(vdev->archive); unzCloseCurrentFile(vdev->archive);
pack_buffer->block_read_positions[ch_index] = 0; // Reset the read position. pack_buffer->block_read_positions[ch_index] = 0; // Reset the read position.
} }
vdev->cur_block++; vdev->cur_block++;
pack_buffer->block_chan_read_pos = 0; pack_buffer->block_chan_read_pos = 0;
@ -1828,8 +1838,41 @@ static int receive_data_dso(int fd, int revents, const struct sr_dev_inst *sdi)
} }
} }
if(vdiv_change) if(timebase_change || vdiv_change)
{ {
int index;
int bit = get_bit(vdev->timebase);
sr_info("bit per circle(double channels):%d",bit);
void* tmp_buf = g_try_malloc0(bit);
for(int i = 0 ; i < bit ; i++)
{
if(i%2 == 0)
{
if(bit == 10)
index = i * 16;
else
index = i * 100 / (bit / 2);
}
else
{
if(bit == 10)
index = (i-1) * 16 + 1;
else
index = (i-1) * 100 / (bit / 2) + 1;
}
*((uint8_t*)tmp_buf+ i) = *((uint8_t*)pack_buffer->post_buf + index + 30);
}
for(int i = 0 ; i < DSO_PACKET_LEN/bit ; i++)
{
memcpy(pack_buffer->post_buf+i*bit,tmp_buf,bit);
}
g_free(tmp_buf);
for(int i = 0 ; i < pack_buffer->post_buf_len; i++) for(int i = 0 ; i < pack_buffer->post_buf_len; i++)
{ {
tem = 0; tem = 0;
@ -1870,18 +1913,17 @@ static int receive_data_dso(int fd, int revents, const struct sr_dev_inst *sdi)
} }
*((uint8_t*)pack_buffer->post_buf + i) = temp_val; *((uint8_t*)pack_buffer->post_buf + i) = temp_val;
} }
timebase_change = FALSE;
vdiv_change = FALSE; vdiv_change = FALSE;
} }
} }
gdouble total_time = vdev->timebase /(gdouble)SR_SEC(1)*(gdouble)10; gdouble total_time = vdev->timebase /(gdouble)SR_SEC(1)*(gdouble)10;
gdouble total_time_elapsed = g_timer_elapsed(run_time, NULL); gdouble total_time_elapsed = g_timer_elapsed(run_time, NULL);
if (total_time_elapsed < total_time && !instant) if (total_time_elapsed < total_time && !instant)
{ {
gdouble percent = total_time_elapsed / total_time; gdouble percent = total_time_elapsed / total_time;
int buf_len = percent* 20000; int buf_len = percent* DSO_PACKET_LEN;
if(buf_len %2 != 0) if(buf_len %2 != 0)
buf_len -=1; buf_len -=1;
pack_buffer->post_len = buf_len; pack_buffer->post_len = buf_len;
@ -1890,15 +1932,15 @@ static int receive_data_dso(int fd, int revents, const struct sr_dev_inst *sdi)
{ {
uint8_t top0; uint8_t top0;
uint8_t top1; uint8_t top1;
if(cur_sample_generator == PATTERN_RANDOM) if(sample_generator == PATTERN_RANDOM)
{ {
top0 = *((uint8_t*)pack_buffer->post_buf + pack_buffer->post_buf_len -2); top0 = *((uint8_t*)pack_buffer->post_buf + pack_buffer->post_buf_len -2);
top1 = *((uint8_t*)pack_buffer->post_buf + pack_buffer->post_buf_len -1); top1 = *((uint8_t*)pack_buffer->post_buf + pack_buffer->post_buf_len -1);
} }
else else
{ {
top0 = *((uint8_t*)pack_buffer->post_buf + 198); top0 = *((uint8_t*)pack_buffer->post_buf + get_bit(vdev->timebase) -2);
top1 = *((uint8_t*)pack_buffer->post_buf + 199); top1 = *((uint8_t*)pack_buffer->post_buf + get_bit(vdev->timebase) -1);
} }
@ -1912,7 +1954,7 @@ static int receive_data_dso(int fd, int revents, const struct sr_dev_inst *sdi)
*(uint8_t*)pack_buffer->post_buf = top0; *(uint8_t*)pack_buffer->post_buf = top0;
*((uint8_t*)pack_buffer->post_buf + 1)= top1; *((uint8_t*)pack_buffer->post_buf + 1)= top1;
pack_buffer->post_len = 20000; pack_buffer->post_len = DSO_PACKET_LEN;
} }
if (pack_buffer->post_len >= byte_align * chan_num) if (pack_buffer->post_len >= byte_align * chan_num)
@ -1955,7 +1997,7 @@ static int receive_data_dso(int fd, int revents, const struct sr_dev_inst *sdi)
static int receive_data_analog(int fd, int revents, const struct sr_dev_inst *sdi) static int receive_data_analog(int fd, int revents, const struct sr_dev_inst *sdi)
{ {
struct session_vdev *vdev = sdi->priv; struct session_vdev *vdev = sdi->priv;
struct sr_datafeed_packet packet; struct sr_datafeed_packet packet;
struct sr_datafeed_analog analog; struct sr_datafeed_analog analog;
struct sr_channel *probe = NULL; struct sr_channel *probe = NULL;
@ -1977,19 +2019,19 @@ static int receive_data_analog(int fd, int revents, const struct sr_dev_inst *sd
g_timer_start(packet_interval); g_timer_start(packet_interval);
if(is_first) if(load_data)
{ {
void* analog_data = g_try_malloc0(206); void* analog_data = g_try_malloc0(ANALOG_DATA_LEN_PER_CYCLE);
if(analog_data == NULL) if(analog_data == NULL)
{ {
sr_err("%s:cant' malloc",__func__); sr_err("%s:cant' malloc",__func__);
return SR_ERR_MALLOC; return SR_ERR_MALLOC;
} }
if(cur_sample_generator == PATTERN_RANDOM) if(sample_generator == PATTERN_RANDOM)
{ {
for(int i = 0 ; i < 206 ;i++) for(int i = 0 ; i < ANALOG_DATA_LEN_PER_CYCLE ;i++)
{ {
*(uint8_t*)(analog_data + i) = rand()%40 +110; *(uint8_t*)(analog_data + i) = ANALOG_RANDOM_DATA;
} }
} }
else else
@ -2010,7 +2052,7 @@ static int receive_data_analog(int fd, int revents, const struct sr_dev_inst *sd
return FALSE; return FALSE;
} }
ret = unzReadCurrentFile(vdev->archive, analog_data, 206); ret = unzReadCurrentFile(vdev->archive, analog_data, ANALOG_DATA_LEN_PER_CYCLE);
if (-1 == ret) if (-1 == ret)
{ {
sr_err("read zip inner file error:\"%s\"", file_name); sr_err("read zip inner file error:\"%s\"", file_name);
@ -2019,14 +2061,11 @@ static int receive_data_analog(int fd, int revents, const struct sr_dev_inst *sd
} }
} }
gdouble rate = 103 / (gdouble)2048 ; uint64_t total_buf_len = ANALOG_CYCLE_RATIO * vdev->total_samples * ANALOG_PROBE_NUM;
uint64_t total_buf_len = rate * vdev->total_samples; if(total_buf_len % ANALOG_DATA_LEN_PER_CYCLE != 0)
if(total_buf_len % 103 != 0)
{ {
total_buf_len = total_buf_len / 103 * 103; total_buf_len = total_buf_len / ANALOG_DATA_LEN_PER_CYCLE * ANALOG_DATA_LEN_PER_CYCLE;
} }
total_buf_len = total_buf_len * 2;
if(vdev->analog_buf != NULL) if(vdev->analog_buf != NULL)
{ {
@ -2039,7 +2078,7 @@ static int receive_data_analog(int fd, int revents, const struct sr_dev_inst *sd
return SR_ERR_MALLOC; return SR_ERR_MALLOC;
} }
vdev->analog_buf_len = total_buf_len; vdev->analog_buf_len = total_buf_len;
uint64_t per_block_after_expend = total_buf_len /206; uint64_t per_block_after_expend = total_buf_len / ANALOG_DATA_LEN_PER_CYCLE;
probe = g_slist_nth(sdi->channels, 0)->data; probe = g_slist_nth(sdi->channels, 0)->data;
uint64_t p0_vdiv = probe->vdiv; uint64_t p0_vdiv = probe->vdiv;
@ -2049,7 +2088,7 @@ static int receive_data_analog(int fd, int revents, const struct sr_dev_inst *sd
uint8_t val = 0; uint8_t val = 0;
uint16_t tem; uint16_t tem;
uint64_t cur_l = 0; uint64_t cur_l = 0;
for(int i = 0 ; i < 206;i++) for(int i = 0 ; i < ANALOG_DATA_LEN_PER_CYCLE;i++)
{ {
if(i == 0 || i % 2 == 0) if(i == 0 || i % 2 == 0)
vdiv = p0_vdiv; vdiv = p0_vdiv;
@ -2061,7 +2100,7 @@ static int receive_data_analog(int fd, int revents, const struct sr_dev_inst *sd
if(temp_value > 128){ if(temp_value > 128){
val = temp_value - 128; val = temp_value - 128;
tem = val * 1000 / vdiv; tem = val * ANALOG_DEFAULT_VDIV / vdiv;
tem = 128 + tem; tem = 128 + tem;
if(tem >= 255) if(tem >= 255)
temp_value = 255; temp_value = 255;
@ -2071,7 +2110,7 @@ static int receive_data_analog(int fd, int revents, const struct sr_dev_inst *sd
else if(temp_value < 128 && temp_value != 0) else if(temp_value < 128 && temp_value != 0)
{ {
val = 128 - temp_value; val = 128 - temp_value;
tem = val * 1000 / vdiv; tem = val * ANALOG_DEFAULT_VDIV / vdiv;
tem = 128 - tem; tem = 128 - tem;
if(tem == 0) if(tem == 0)
temp_value = 1; temp_value = 1;
@ -2088,12 +2127,12 @@ static int receive_data_analog(int fd, int revents, const struct sr_dev_inst *sd
else else
{ {
cur_l = 1 + (i - 1) * per_block_after_expend + j * 2; cur_l = 1 + (i - 1) * per_block_after_expend + j * 2;
} }
memset(vdev->analog_buf + cur_l,temp_value,1); memset(vdev->analog_buf + cur_l,temp_value,1);
} }
} }
is_first = FALSE; g_safe_free(analog_data);
load_data = FALSE;
} }
void* buf; void* buf;
@ -2154,7 +2193,7 @@ static void send_error_packet(const struct sr_dev_inst *cb_sdi, struct session_v
static int close_archive(struct session_vdev *vdev) static int close_archive(struct session_vdev *vdev)
{ {
if(cur_sample_generator != PATTERN_RANDOM) if(sample_generator != PATTERN_RANDOM)
{ {
assert(vdev->archive); assert(vdev->archive);
@ -2198,12 +2237,12 @@ static int load_virtual_device_session(struct sr_dev_inst *sdi)
int version = 1; int version = 1;
assert(sdi); assert(sdi);
if (cur_sample_generator != PATTERN_RANDOM) if (sample_generator != PATTERN_RANDOM)
{ {
assert(sdi->path); assert(sdi->path);
} }
if (sdi->mode == LOGIC && cur_sample_generator == PATTERN_RANDOM) if (sdi->mode == LOGIC && sample_generator == PATTERN_RANDOM)
{ {
sdi->driver->config_set(SR_CONF_SAMPLERATE, sdi->driver->config_set(SR_CONF_SAMPLERATE,
g_variant_new_uint64(SR_MHZ(1)), sdi, NULL, NULL); g_variant_new_uint64(SR_MHZ(1)), sdi, NULL, NULL);

42
libsigrok4DSL/hardware/demo/demo.h
View File

@ -42,7 +42,7 @@ static uint64_t samplerates_file[1];
static uint64_t samplecounts_file[1]; static uint64_t samplecounts_file[1];
static GTimer *packet_interval = NULL; static GTimer *packet_interval = NULL;
static GTimer *run_time = NULL; static GTimer *run_time = NULL;
static gboolean is_first = TRUE; static gboolean load_data = TRUE;
static gboolean is_change = FALSE; static gboolean is_change = FALSE;
static int enabled_probe_num; static int enabled_probe_num;
static uint64_t packet_len; static uint64_t packet_len;
@ -54,8 +54,8 @@ static gboolean timebase_change;
static gboolean instant = FALSE; static gboolean instant = FALSE;
static int max_probe_num = 0; static int max_probe_num = 0;
extern char DS_RES_PATH[500]; extern char DS_RES_PATH[500];
uint8_t cur_sample_generator; uint8_t sample_generator;
uint8_t pre_sample_generator; static int64_t analog_count = 0;
struct session_packet_buffer; struct session_packet_buffer;
@ -250,6 +250,30 @@ static const uint64_t samplerates[] = {
#define CAPS_FEATURE_ZERO (1 << 4) #define CAPS_FEATURE_ZERO (1 << 4)
/* end */ /* end */
#define SEC 1
#define POST_DATA_PER_SECOND(n) ((n)/(8))
#define LOGIC_MAX_PROBE_NUM 16
#define LOGIC_PACKET_NUM_PER_SEC (double)200
#define LOGIC_PACKET_LEN floor(packet_len/8)*8
#define LOGIC_HIGH_LEVEL 255
#define LOGIC_LOW_LEVEL 0
#define LOGIC_HW_DEPTH (SR_MHZ(100))
#define DSO_PACKET_LEN 20000
#define DSO_PACKET_NUM_PER_SEC (double)200
#define ANALOG_CYCLE_RATIO ((gdouble)(103) / (gdouble)(2048))
#define ANALOG_HW_DEPTH (SR_MHZ(12.5))
#define ANALOG_DATA_LEN_PER_CYCLE 206
#define ANALOG_RANDOM_DATA rand()%40 +110
#define ANALOG_PROBE_NUM 2
#define ANALOG_DEFAULT_VDIV 1000
#define ANALOG_RETE(n) ((n/SR_HZ(10)))
// #define LOGIC_UNIT_BITS
static const char *maxHeights[] = { static const char *maxHeights[] = {
"1X", "1X",
@ -413,19 +437,21 @@ static const int ranx[] = {
-41, 36, -8, 46, 47, -34, 28, -39, 7, -32, 38, -27, 28, -3, -8, 43, -37, -24, 6, 3, -41, 36, -8, 46, 47, -34, 28, -39, 7, -32, 38, -27, 28, -3, -8, 43, -37, -24, 6, 3,
}; };
static int get_bit(uint64_t timebase);
static int reset_dsl_path(struct sr_dev_inst *sdi,uint8_t device_mode ,uint8_t pattern_mode);
static int get_pattern_mode_index_by_string(uint8_t device_mode , const char* str);
static int get_pattern_mode_from_file(uint8_t device_mode); static int get_pattern_mode_from_file(uint8_t device_mode);
static int init_pattern_mode_list(); static int init_pattern_mode_list();
static int get_pattern_mode_index_by_string(uint8_t device_mode , const char* str);
static int scan_dsl_file(struct sr_dev_inst *sdi); static int scan_dsl_file(struct sr_dev_inst *sdi);
static char* get_dsl_path_by_pattern_mode(uint8_t device_mode ,uint8_t pattern_mode);
static void adjust_samplerate(struct sr_dev_inst *sdi); static void adjust_samplerate(struct sr_dev_inst *sdi);
static int init_random_data(struct session_vdev * vdev); static int init_random_data(struct session_vdev * vdev,struct sr_dev_inst *sdi);
static int hw_init(struct sr_context *sr_ctx); static int hw_init(struct sr_context *sr_ctx);