bool Frontend::GetLockStatus( uint8_t &signal, uint8_t &noise, int timeout )
{
if( !fe )
return false;
uint32_t snr = 0, sig = 0;
uint32_t ber = 0, unc = 0;
struct timeval ts;
gettimeofday( &ts, NULL );
long start = ts.tv_sec * 1000 + ts.tv_usec / 1000; // milli seconds
while( state == State_Tuning && up )
{
int r = dvb_fe_get_stats( fe );
if( r != 0 )
{
LogError( "Error getting frontend status" );
return false;
}
uint32_t status = 0;
dvb_fe_retrieve_stats( fe, DTV_STATUS, &status );
dvb_fe_retrieve_stats( fe, DTV_BER, &ber );
dvb_fe_retrieve_stats( fe, DTV_SIGNAL_STRENGTH, &sig );
dvb_fe_retrieve_stats( fe, DTV_UNCORRECTED_BLOCKS, &unc );
dvb_fe_retrieve_stats( fe, DTV_SNR, &snr );
sig *= 100;
sig /= 0xffff;
snr *= 100;
snr /= 0xffff;
if( status & FE_HAS_LOCK )
{
//if( i > 0 )
//printf( "\n" );
Log( "Tuned: sig=%3u%% snr=%3u%% ber=%d unc=%d", (unsigned int) sig, (unsigned int) snr, ber, unc );
//Log( "Tuned: sig=%3u%% snr=%3u%% ber=%d unc=%d", (unsigned int) sig, (unsigned int) snr, ber, unc );
signal = sig;
noise = snr;
return true;
}
else
Log( "Tuned: sig=%3u%% snr=%3u%% ber=%d unc=%d", (unsigned int) sig, (unsigned int) snr, ber, unc );
struct timeval ts2;
gettimeofday( &ts2, NULL );
if(( ts2.tv_sec * 1000 + ts2.tv_usec / 1000 ) - start > timeout )
break;
usleep( 100000 );
//printf( "." );
//fflush( stdout );
}
//printf( "\n" );
return false;
}
static int check_frontend(struct arguments *args, struct dvb_v5_fe_parms *parms)
{
int rc, i;
fe_status_t status;
args->n_status_lines = 0;
for (i = 0; i < args->timeout_multiply * 40; i++) {
rc = dvb_fe_get_stats(parms);
if (rc)
PERROR("dvb_fe_get_stats failed");
rc = dvb_fe_retrieve_stats(parms, DTV_STATUS, &status);
if (rc)
status = 0;
print_frontend_stats(args, parms);
if (status & FE_HAS_LOCK)
break;
usleep(100000);
};
if (isatty(STDERR_FILENO)) {
fprintf(stderr, "\x1b[37m");
}
return (status & FE_HAS_LOCK) ? 0 : -1;
}
static int check_frontend(struct arguments *args,
struct dvb_v5_fe_parms *parms)
{
int rc;
fe_status_t status = 0;
do {
rc = dvb_fe_get_stats(parms);
if (rc) {
PERROR(_("dvb_fe_get_stats failed"));
usleep(1000000);
continue;
}
status = 0;
rc = dvb_fe_retrieve_stats(parms, DTV_STATUS, &status);
if (!args->silent)
print_frontend_stats(stderr, args, parms);
if (status & FE_HAS_LOCK)
break;
usleep(1000000);
} while (!timeout_flag);
if (args->silent < 2)
print_frontend_stats(stderr, args, parms);
return status & FE_HAS_LOCK;
}
float dvb_fe_retrieve_ber(struct dvb_v5_fe_parms *p, unsigned layer,
enum fecap_scale_params *scale)
{
struct dvb_v5_fe_parms_priv *parms = (void *)p;
float ber;
uint32_t ber32;
if (parms->p.has_v5_stats) {
ber = calculate_postBER(parms, layer);
if (ber >= 0)
*scale = FE_SCALE_COUNTER;
else
*scale = FE_SCALE_NOT_AVAILABLE;
return ber;
}
if (layer) {
*scale = FE_SCALE_NOT_AVAILABLE;
return -1;
}
if (dvb_fe_retrieve_stats(&parms->p, DTV_BER, &ber32))
*scale = FE_SCALE_NOT_AVAILABLE;
else
*scale = FE_SCALE_RELATIVE;
return ber32;
}
static int print_frontend_stats(struct dvb_v5_fe_parms *parms,
int human_readable)
{
int rc;
fe_status_t status;
uint32_t snr = 0, _signal = 0;
uint32_t ber = 0, uncorrected_blocks = 0;
rc = dvb_fe_get_stats(parms);
if (rc < 0) {
PERROR("dvb_fe_get_stats failed");
return -1;
}
rc = dvb_fe_retrieve_stats(parms, DTV_STATUS, &status);
rc += dvb_fe_retrieve_stats(parms, DTV_BER, &ber);
rc += dvb_fe_retrieve_stats(parms, DTV_SIGNAL_STRENGTH, &_signal);
rc += dvb_fe_retrieve_stats(parms, DTV_UNCORRECTED_BLOCKS,
&uncorrected_blocks);
rc += dvb_fe_retrieve_stats(parms, DTV_SNR, &snr);
if (human_readable) {
printf("status %02x | signal %3u%% | snr %3u%% | ber %d | unc %d | ",
status, (_signal * 100) / 0xffff, (snr * 100) / 0xffff,
ber, uncorrected_blocks);
} else {
fprintf(stderr,
"status %02x | signal %04x | snr %04x | ber %08x | unc %08x | ",
status, _signal, snr, ber, uncorrected_blocks);
}
if (status & FE_HAS_LOCK) {
fprintf(stderr, "FE_HAS_LOCK");
if (!(old_status & FE_HAS_LOCK)) {
fprintf(stderr, "\n");
dvb_fe_get_parms(parms);
}
}
old_status = status;
fprintf(stderr, "\n");
return 0;
}
static int check_frontend(struct arguments *args,
struct dvb_v5_fe_parms *parms)
{
int rc;
fe_status_t status;
do {
rc = dvb_fe_get_stats(parms);
if (rc < 0)
PERROR("dvb_fe_get_stats failed");
rc = dvb_fe_retrieve_stats(parms, DTV_STATUS, &status);
if (!args->silent)
print_frontend_stats(parms, args->human_readable);
if (args->exit_after_tuning && (status & FE_HAS_LOCK))
break;
usleep(1000000);
} while (!timeout_flag);
if (args->silent < 2)
print_frontend_stats(parms, args->human_readable);
return 0;
}
static int print_frontend_stats(struct arguments *args,
struct dvb_v5_fe_parms *parms)
{
char buf[512], *p;
int rc, i, len, show;
uint32_t status = 0;
/* Move cursor up and cleans down */
if (isatty(STDERR_FILENO) && args->n_status_lines)
fprintf(stderr, "\r\x1b[%dA\x1b[J", args->n_status_lines);
args->n_status_lines = 0;
if (isatty(STDERR_FILENO)) {
rc = dvb_fe_retrieve_stats(parms, DTV_STATUS, &status);
if (rc)
status = 0;
if (status & FE_HAS_LOCK)
fprintf(stderr, "\x1b[1;32m");
else
fprintf(stderr, "\x1b[33m");
}
p = buf;
len = sizeof(buf);
dvb_fe_snprintf_stat(parms, DTV_STATUS, NULL, 0, &p, &len, &show);
for (i = 0; i < MAX_DTV_STATS; i++) {
show = 1;
dvb_fe_snprintf_stat(parms, DTV_QUALITY, "Quality",
i, &p, &len, &show);
dvb_fe_snprintf_stat(parms, DTV_STAT_SIGNAL_STRENGTH, "Signal",
i, &p, &len, &show);
dvb_fe_snprintf_stat(parms, DTV_STAT_CNR, "C/N",
i, &p, &len, &show);
dvb_fe_snprintf_stat(parms, DTV_STAT_ERROR_BLOCK_COUNT, "UCB",
i, &p, &len, &show);
dvb_fe_snprintf_stat(parms, DTV_BER, "postBER",
i, &p, &len, &show);
dvb_fe_snprintf_stat(parms, DTV_PRE_BER, "preBER",
i, &p, &len, &show);
dvb_fe_snprintf_stat(parms, DTV_PER, "PER",
i, &p, &len, &show);
if (p != buf) {
if (args->n_status_lines)
fprintf(stderr, "\t%s\n", buf);
else
fprintf(stderr, "%s\n", buf);
args->n_status_lines++;
p = buf;
len = sizeof(buf);
}
}
fflush(stderr);
return 0;
}
static int print_frontend_stats(FILE *fd,
struct arguments *args,
struct dvb_v5_fe_parms *parms)
{
char buf[512], *p;
int rc, i, len, show;
uint32_t status = 0;
/* Move cursor up and cleans down */
if (isatty(fileno(fd)) && args->n_status_lines)
fprintf(fd, "\r\x1b[%dA\x1b[J", args->n_status_lines);
args->n_status_lines = 0;
rc = dvb_fe_get_stats(parms);
if (rc) {
PERROR(_("dvb_fe_get_stats failed"));
return -1;
}
p = buf;
len = sizeof(buf);
dvb_fe_snprintf_stat(parms, DTV_STATUS, NULL, 0, &p, &len, &show);
for (i = 0; i < MAX_DTV_STATS; i++) {
show = 1;
dvb_fe_snprintf_stat(parms, DTV_QUALITY, _("Quality"),
i, &p, &len, &show);
dvb_fe_snprintf_stat(parms, DTV_STAT_SIGNAL_STRENGTH, _("Signal"),
i, &p, &len, &show);
dvb_fe_snprintf_stat(parms, DTV_STAT_CNR, _("C/N"),
i, &p, &len, &show);
dvb_fe_snprintf_stat(parms, DTV_STAT_ERROR_BLOCK_COUNT, _("UCB"),
i, &p, &len, &show);
dvb_fe_snprintf_stat(parms, DTV_BER, _("postBER"),
i, &p, &len, &show);
dvb_fe_snprintf_stat(parms, DTV_PRE_BER, _("preBER"),
i, &p, &len, &show);
dvb_fe_snprintf_stat(parms, DTV_PER, _("PER"),
i, &p, &len, &show);
if (p != buf) {
if (args->n_status_lines)
fprintf(fd, "\t%s\n", buf);
else
fprintf(fd, "%s\n", buf);
args->n_status_lines++;
p = buf;
len = sizeof(buf);
}
}
fflush(fd);
/* While not lock, display status on a new line */
dvb_fe_retrieve_stats(parms, DTV_STATUS, &status);
if (!isatty(fileno(fd)) || !(status & FE_HAS_LOCK))
fprintf(fd, "\n");
return 0;
}
int dvb_fe_snprintf_stat(struct dvb_v5_fe_parms *p, uint32_t cmd,
char *display_name, int layer,
char **buf, int *len, int *show_layer_name)
{
struct dvb_v5_fe_parms_priv *parms = (void *)p;
struct dtv_stats *stat = NULL;
enum dvb_quality qual = DVB_QUAL_UNKNOWN;
enum fecap_scale_params scale;
float val = -1;
int initial_len = *len;
int size, i;
/* Print status, if layer == 0, as there is only global status */
if (cmd == DTV_STATUS) {
fe_status_t status;
if (layer)
return 0;
if (dvb_fe_retrieve_stats(&parms->p, DTV_STATUS, &status)) {
dvb_logerr (_("Error: no adapter status"));
return -1;
}
if (display_name) {
size = snprintf(*buf, *len, " %s=", display_name);
*buf += size;
*len -= size;
}
/* Get the name of the highest status bit */
for (i = ARRAY_SIZE(sig_bits) - 1; i >= 0 ; i--) {
if ((1 << i) & status) {
size = snprintf(*buf, *len, _("%-7s"), _(sig_bits[i]));
*buf += size;
*len -= size;
break;
}
}
if (i < 0) {
size = snprintf(*buf, *len, _("%7s"), "");
*buf += size;
*len -= size;
}
/* Add the status bits */
size = snprintf(*buf, *len, "(0x%02x)", status);
*buf += size;
*len -= size;
return initial_len - *len;
}
/* Retrieve the statistics */
switch (cmd) {
case DTV_PRE_BER:
val = calculate_preBER(parms, layer);
if (val < 0)
return 0;
scale = FE_SCALE_COUNTER;
break;
case DTV_BER:
val = dvb_fe_retrieve_ber(&parms->p, layer, &scale);
if (scale == FE_SCALE_NOT_AVAILABLE)
return 0;
break;
case DTV_PER:
val = dvb_fe_retrieve_per(&parms->p, layer);
if (val < 0)
return 0;
scale = FE_SCALE_COUNTER;
break;
case DTV_QUALITY:
qual = dvb_fe_retrieve_quality(&parms->p, layer);
if (qual == DVB_QUAL_UNKNOWN)
return 0;
break;
default:
stat = dvb_fe_retrieve_stats_layer(&parms->p, cmd, layer);
if (!stat || stat->scale == FE_SCALE_NOT_AVAILABLE)
return 0;
}
/* If requested, prints the layer name */
if (*show_layer_name && layer) {
size = snprintf(*buf, *len, _(" Layer %c:"), 'A' + layer - 1);
*buf += size;
*len -= size;
*show_layer_name = 0;
}
if (display_name) {
size = snprintf(*buf, *len, " %s=", display_name);
*buf += size;
*len -= size;
}
/* Quality measure */
if (qual != DVB_QUAL_UNKNOWN) {
size = snprintf(*buf, *len, " %-4s", _(qual_name[qual]));
*buf += size;
*len -= size;
return initial_len - *len;
}
/* Special case: float point measures like BER/PER */
if (!stat) {
switch (scale) {
case FE_SCALE_RELATIVE:
size = snprintf(*buf, *len, " %u", (unsigned int)val);
break;
case FE_SCALE_COUNTER:
size = dvb_fe_snprintf_eng(*buf, *len, val);
break;
default:
size = 0;
}
*buf += size;
*len -= size;
return initial_len - *len;
}
/* Prints the scale */
switch (stat->scale) {
case FE_SCALE_DECIBEL:
if (cmd == DTV_STAT_SIGNAL_STRENGTH)
size = snprintf(*buf, *len, " %.2fdBm", stat->svalue / 1000.);
else
size = snprintf(*buf, *len, " %.2fdB", stat->svalue / 1000.);
break;
case FE_SCALE_RELATIVE:
size = snprintf(*buf, *len, " %3.2f%%", (100 * stat->uvalue) / 65535.);
break;
case FE_SCALE_COUNTER:
size = snprintf(*buf, *len, " %" PRIu64, (uint64_t)stat->uvalue);
break;
default:
size = 0;
}
*buf += size;
*len -= size;
return initial_len - *len;
}
