int dvb_fe_get_event(struct dvb_v5_fe_parms *p)
{
struct dvb_v5_fe_parms_priv *parms = (void *)p;
struct dvb_frontend_event event;
fe_status_t status;
int i;
if (!parms->p.legacy_fe) {
dvb_fe_get_parms(&parms->p);
return dvb_fe_get_stats(&parms->p);
}
if (xioctl(parms->fd, FE_GET_EVENT, &event) == -1) {
dvb_perror("FE_GET_EVENT");
return errno;
}
status = event.status;
if (parms->p.verbose > 1) {
dvb_log(_("Status: "));
for (i = 0; i < ARRAY_SIZE(fe_status_name); i++) {
if (status & fe_status_name[i].idx)
dvb_log (" %s", fe_status_name[i].name);
}
}
dvb_fe_store_stats(parms, DTV_STATUS, FE_SCALE_RELATIVE, 0, status);
dvb_fe_retrieve_parm(&parms->p, DTV_FREQUENCY, &event.parameters.frequency);
dvb_fe_retrieve_parm(&parms->p, DTV_INVERSION, &event.parameters.inversion);
switch (parms->p.current_sys) {
case SYS_DVBS:
dvb_fe_retrieve_parm(&parms->p, DTV_SYMBOL_RATE, &event.parameters.u.qpsk.symbol_rate);
dvb_fe_retrieve_parm(&parms->p, DTV_INNER_FEC, &event.parameters.u.qpsk.fec_inner);
break;
case SYS_DVBC_ANNEX_AC:
dvb_fe_retrieve_parm(&parms->p, DTV_SYMBOL_RATE, &event.parameters.u.qam.symbol_rate);
dvb_fe_retrieve_parm(&parms->p, DTV_INNER_FEC, &event.parameters.u.qam.fec_inner);
dvb_fe_retrieve_parm(&parms->p, DTV_MODULATION, &event.parameters.u.qam.modulation);
break;
case SYS_ATSC:
case SYS_ATSCMH:
case SYS_DVBC_ANNEX_B:
dvb_fe_retrieve_parm(&parms->p, DTV_MODULATION, &event.parameters.u.vsb.modulation);
break;
case SYS_DVBT:
dvb_fe_retrieve_parm(&parms->p, DTV_BANDWIDTH_HZ, &event.parameters.u.ofdm.bandwidth);
dvb_fe_retrieve_parm(&parms->p, DTV_CODE_RATE_HP, &event.parameters.u.ofdm.code_rate_HP);
dvb_fe_retrieve_parm(&parms->p, DTV_CODE_RATE_LP, &event.parameters.u.ofdm.code_rate_LP);
dvb_fe_retrieve_parm(&parms->p, DTV_MODULATION, &event.parameters.u.ofdm.constellation);
dvb_fe_retrieve_parm(&parms->p, DTV_TRANSMISSION_MODE, &event.parameters.u.ofdm.transmission_mode);
dvb_fe_retrieve_parm(&parms->p, DTV_GUARD_INTERVAL, &event.parameters.u.ofdm.guard_interval);
dvb_fe_retrieve_parm(&parms->p, DTV_HIERARCHY, &event.parameters.u.ofdm.hierarchy_information);
break;
default:
return EINVAL;
}
return dvb_fe_get_stats(&parms->p);
}
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;
}
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 void get_show_stats(struct arguments *args,
struct dvb_v5_fe_parms *parms,
int loop)
{
int rc;
args->n_status_lines = 0;
do {
rc = dvb_fe_get_stats(parms);
if (!rc)
print_frontend_stats(stderr, args, parms);
if (!timeout_flag && loop)
usleep(1000000);
} while (!timeout_flag && loop);
}
static void get_show_stats(struct dvb_v5_fe_parms *parms)
{
int rc;
signal(SIGTERM, do_timeout);
signal(SIGINT, do_timeout);
do {
rc = dvb_fe_get_stats(parms);
if (!rc)
print_frontend_stats(stderr, parms);
if (!timeout_flag)
usleep(1000000);
} while (!timeout_flag);
}
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(FILE *fd,
struct dvb_v5_fe_parms *parms)
{
char buf[512], *p;
int rc, i, len, show, n_status_lines = 0;
rc = dvb_fe_get_stats(parms);
if (rc) {
ERROR(_("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 (isatty(fileno(fd))) {
enum dvb_quality qual;
int color;
qual = dvb_fe_retrieve_quality(parms, 0);
switch (qual) {
case DVB_QUAL_POOR:
color = 31;
break;
case DVB_QUAL_OK:
color = 36;
break;
case DVB_QUAL_GOOD:
color = 32;
break;
case DVB_QUAL_UNKNOWN:
default:
color = 0;
break;
}
fprintf(fd, "\033[%dm", color);
/*
* It would be great to change the BELL
* tone depending on the quality. The legacy
* femon used to to that, but this doesn't
* work anymore with modern Linux distros.
*
* So, just print a bell if quality is good.
*
* The console audio should be enabled
* at the window manater for this to
* work.
*/
if (acoustical) {
if (qual == DVB_QUAL_GOOD)
fprintf(fd, "\a");
}
}
if (n_status_lines)
fprintf(fd, "\t%s\n", buf);
else
fprintf(fd, "%s\n", buf);
n_status_lines++;
p = buf;
len = sizeof(buf);
}
}
fflush(fd);
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;
}
