adtest.c

// Copyright (c) <2012> <Leif Asbrink>
//
// Permission is hereby granted, free of charge, to any person 
// obtaining a copy of this software and associated documentation 
// files (the "Software"), to deal in the Software without restriction, 
// including without limitation the rights to use, copy, modify, 
// merge, publish, distribute, sublicense, and/or sell copies of 
// the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be 
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE 
// OR OTHER DEALINGS IN THE SOFTWARE.


#define LOG_ZERO -0.8
#define LINFAC 0.000025F

#include <unistd.h>
#include "globdef.h"
#include "uidef.h"
#include "fft1def.h"
#include "screendef.h"
#include "rusage.h"
#include "thrdef.h"
#include "powtdef.h"

#define OUTTEST_SIZE 16
#define LAST_LINE 9

float *ch1_y;
float *ch2_y; 
int *ch1_yold;
int *ch2_yold; 
int adtest_yzer;
int adtest_ymax;

void show_adtest(void)
{   
float ya, yb;
int x;
if(powtim_displaymode == 0)
  {
  if( (ui.rx_input_mode&IQ_DATA) != 0)
    {
    for(x=0; x<screen_width; x++)
      {
      lir_setpixel(x,ch1_yold[x],ADTEST_BACKGROUND_COLOR);
      lir_setpixel(x,ch2_yold[x],ADTEST_BACKGROUND_COLOR);
      ya=ch1_y[x];
      yb=ch2_y[x];
      ya*=(float)adtest_scale*LINFAC;  
      if(ya < -1)ya=-1;
      if(ya >  1)ya= 1; 
      yb*=(float)adtest_scale*LINFAC;  
      if(yb < -1)yb=-1;
      if(yb >  1)yb= 1; 
      ch1_yold[x]=adtest_yzer-(int)(ya*(float)adtest_ymax);
      ch2_yold[x]=adtest_yzer-(int)(yb*(float)adtest_ymax);
      if(ch1_yold[x] == ch2_yold[x]) 
        {
        lir_setpixel(x,ch1_yold[x],15);
        }
      else
        {
        lir_setpixel(x,ch1_yold[x],14);
        lir_setpixel(x,ch2_yold[x],12);
        }
      }
    }  
  else
    {
    for(x=0; x<screen_width; x++)
      {
      lir_setpixel(x,ch1_yold[x],ADTEST_BACKGROUND_COLOR);
      ya=ch1_y[x];
      ya*=(float)adtest_scale*LINFAC;  
      if(ya < -1)ya=-1;
      if(ya >  1)ya= 1; 
      ch1_yold[x]=adtest_yzer-(int)(ya*(float)adtest_ymax);
      lir_setpixel(x,ch1_yold[x],15);
      }
    }
  }
else
  {
  if( (ui.rx_input_mode&IQ_DATA) != 0)
    {
    for(x=1; x<screen_width; x++)
      {
      lir_line(x-1,ch1_yold[x-1],x,ch1_yold[x],ADTEST_BACKGROUND_COLOR);
      if(kill_all_flag) return;
      lir_line(x-1,ch2_yold[x-1],x,ch2_yold[x],ADTEST_BACKGROUND_COLOR);
      if(kill_all_flag) return;
      } 
    for(x=1; x<screen_width; x++)
      {
      ya=ch1_y[x];
      yb=ch2_y[x];
      ya*=(float)adtest_scale*LINFAC;  
      if(ya < -1)ya=-1;
      if(ya >  1)ya= 1; 
      yb*=(float)(adtest_scale*LINFAC);  
      if(yb < -1)yb=-1;
      if(yb >  1)yb= 1; 
      ch1_yold[x]=adtest_yzer-(int)(ya*(float)adtest_ymax);
      ch2_yold[x]=adtest_yzer-(int)(yb*(float)adtest_ymax);
      lir_line(x-1,ch1_yold[x-1],x,ch1_yold[x],14);
      if(kill_all_flag) return;
      lir_line(x-1,ch2_yold[x-1],x,ch2_yold[x],12);
      if(kill_all_flag) return;
      }
    }  
  else
    {
    for(x=0; x<screen_width; x++)
      {
      lir_setpixel(x,ch1_yold[x],ADTEST_BACKGROUND_COLOR);
      ya=ch1_y[x];
      ya*=(float)(adtest_scale*LINFAC);  
      if(ya < -1)ya=-1;
      if(ya >  1)ya= 1; 
      ch1_yold[x]=adtest_yzer-(int)(ya*(float)adtest_ymax);
      lir_setpixel(x,ch1_yold[x],15);
      }
    }
  }
lir_refresh_screen();
}



void rx_adtest(void)
{
int local_workload_reset;
int local_adtest_new;
int i, j, x, p0, p_increment, points, px, p_max;
int maxmin_counter;
int ad_maxval1,ad_minval1,ad_maxval2,ad_minval2;
float ya,yb;
int pixmode;
char s[80];
clear_screen();
ch1_y=fftw_tmp;
ch2_y=&fftw_tmp[screen_width];
ch1_yold=(int*)&fftw_tmp[2*screen_width];
ch2_yold=(int*)&fftw_tmp[3*screen_width];;
local_workload_reset=workload_reset_flag;
local_adtest_new=adtest_new;
ad_maxval1=0;
ad_minval1=0;
ad_maxval2=0;
ad_minval2=0;
maxmin_counter=0;
settextcolor(14);
lir_text(10,0,"TEST OF A/D INPUT for RX");
lir_text(38,0,"Make sure frequency and gain are set.");
settextcolor(7);
lir_text(38,0,"Make sure frequency and gain are set.");
lir_text(0,1,
"Press 'X' twice, on a normal receive mode before using this screen.");
adtest_scale=1;
powtim_pause_flag=0;
adtest_new=0;
adtest_channel=0;
powtim_displaymode=0;
// Use lines 1 to LAST_LINE+2 for text messages.
i=(LAST_LINE+2)*text_height;
i+=text_height/2;
j=screen_height-i;
if(j < 4*text_height)
  {
  lirerr(1046);
  goto adtest_exit;
  }
j/=2;
adtest_yzer=screen_height-j-1;
adtest_ymax=j;
for(i=0; i<screen_width; i++)
  {
  ch1_yold[i]=adtest_yzer;
  ch2_yold[i]=adtest_yzer;
  }
restart:;
thread_status_flag[THREAD_RX_ADTEST]=THRFLAG_ACTIVE;
yb=0;
lir_fillbox(0,adtest_yzer-adtest_ymax, screen_width-1,screen_height
                          -adtest_yzer+adtest_ymax-1, ADTEST_BACKGROUND_COLOR);
if(ui.rx_rf_channels == 2)
  {
  sprintf(s,"Channel = %d   'C' to toggle channel.",adtest_channel);
  lir_text(3,3,s);
  }
if(powtim_pause_flag == 0)
  {
  lir_text(3,4,"'P' to pause.");
  }
else
  {
  lir_text(3,4,"'R' to resume.");
  show_adtest();
  if(kill_all_flag) goto adtest_exit;
  }
lir_text(3,5,"'W' to toggle line/pixels.");
lir_text(3,6,"+/- to change scale.");
x=0;
timf1p_px=timf1p_pa;
pixmode=adtest_channel*2;
if( ui.rx_rf_channels == 2)pixmode++;
pixmode*=2;
if( (ui.rx_input_mode&IQ_DATA) != 0)pixmode++;
pixmode*=2;
if( (ui.rx_input_mode&DWORD_INPUT) == 0)pixmode++;
//pixmode bit0  0=>32bit        1=>16bit.
//pixmode bit1  0=>normal       1=>IQ data
//pixmode bit2  0=>one          1=>two rx channels
//pixmode bit3  channel 0 or 1 (if two channels)
settextcolor(15);
sprintf(s,"pixmode=%d      scale=%3.3fdB (%f) ",
                             pixmode,20*log10(adtest_scale),adtest_scale);
lir_text(1,LAST_LINE-1,s);
while(thread_command_flag[THREAD_RX_ADTEST] == THRFLAG_ACTIVE)
  {
  if(local_workload_reset!=workload_reset_flag)
    {
    ad_maxval1=0;
    ad_minval1=0;
    ad_maxval2=0;
    ad_minval2=0;
    maxmin_counter=0;
    local_workload_reset=workload_reset_flag;
    }
  lir_await_event(EVENT_TIMF1);
  if(powtim_pause_flag != 0)timf1p_px = timf1p_pa;
  if(timf1p_px != timf1p_pa)
    {
    points=((timf1p_pa-timf1p_px+timf1_bytes)&timf1_bytemask)/
                                                       snd[RXAD].framesize; 
    if(points > screen_width)
      {
      points=screen_width;
      timf1p_px=(timf1p_pa-points*snd[RXAD].framesize+timf1_bytes)&
                                                          timf1_bytemask;
      }                                                          
    p0=(timf1p_px-snd[RXAD].block_bytes+timf1_bytes)&timf1_bytemask;
    timf1p_px=timf1p_pa;
    p_increment=snd[RXAD].framesize;
    p_max=timf1_bytes;
    if(  (ui.rx_input_mode&DWORD_INPUT) == 0)
      {
      p_increment/=(int)sizeof(short int);
      p_max/=(int)sizeof(short int);
      p0/=(int)sizeof(short int);
      }
    else
      {
      p_increment/=(int)sizeof(int);
      p_max/=(int)sizeof(int);
      p0/=(int)sizeof(int);
      }
    p_max--;
    maxmin_counter+=points;  
    if(maxmin_counter > ui.rx_ad_speed/4)
      {
      if(  (ui.rx_input_mode&DWORD_INPUT) != 0)
        {
        ad_maxval1/=2048;
        ad_minval1/=2048;
        ad_maxval2/=2048;
        ad_minval2/=2048;
        }
      sprintf(s,"AD max = %06d   ",ad_maxval1);
      lir_text(1,LAST_LINE,s); 
      sprintf(s,"AD min = %06d   ",ad_minval1);
      lir_text(41,LAST_LINE,s);
      if(  (ui.rx_input_mode&IQ_DATA) != 0)
        {
        sprintf(s,"%06d   ",ad_maxval2);
        lir_text(22,LAST_LINE,s); 
        sprintf(s,"%06d   ",ad_minval2);
        lir_text(62,LAST_LINE,s);
        }
      ad_maxval1=ad_minval1=ad_maxval2=ad_minval2=0;
      maxmin_counter=0;
      }
    sprintf(s,"N=%d inc=%d ",points,p_increment);
    lir_text(60,LAST_LINE-1,s);
    i=0;
    for( px=0; px<points; px++)
      {
      switch (pixmode)
        {
        case 0:   // One channel 32 bit. Oscilloscope raw data 
        case 4:   // Two channels 32 bit. Oscilloscope raw data ch0
        if(ad_maxval1<timf1_int[p0])ad_maxval1=timf1_int[p0];
        if(ad_minval1>timf1_int[p0])ad_minval1=timf1_int[p0];
        ya=(float)(timf1_int[p0])/65536;

        break;

        case 1:   // One channel 16 bit. Oscilloscope raw data 
        case 5:   // Two channels 16 bit. Oscilloscope raw data ch0
        if(ad_maxval1<timf1_short_int[p0])ad_maxval1=timf1_short_int[p0];
        if(ad_minval1>timf1_short_int[p0])ad_minval1=timf1_short_int[p0];
        ya=timf1_short_int[p0];
        break;
  
        case 2:   // One channel IQ 32 bit. Oscilloscope raw data.   
        case 6:   // Two channels IQ 32 bit. Oscilloscope raw data ch0.
        if(ad_maxval1<timf1_int[p0  ])ad_maxval1=timf1_int[p0  ];
        if(ad_minval1>timf1_int[p0  ])ad_minval1=timf1_int[p0  ];
        if(ad_maxval2<timf1_int[p0+1])ad_maxval2=timf1_int[p0+1];
        if(ad_minval2>timf1_int[p0+1])ad_minval2=timf1_int[p0+1];
        ya=(float)(timf1_int[p0  ])/65536;
        yb=(float)(timf1_int[p0+1])/65536;
        break;

        case 3:   // One channel IQ 16 bit. Oscilloscope raw data.   
        case 7:   // Two channels IQ 16 bit. Oscilloscope raw data ch0.
        if(ad_maxval1<timf1_short_int[p0  ])ad_maxval1=timf1_short_int[p0  ];
        if(ad_minval1>timf1_short_int[p0  ])ad_minval1=timf1_short_int[p0  ];
        if(ad_maxval2<timf1_short_int[p0+1])ad_maxval2=timf1_short_int[p0+1];
        if(ad_minval2>timf1_short_int[p0+1])ad_minval2=timf1_short_int[p0+1];
        ya=timf1_short_int[p0  ];
        yb=timf1_short_int[p0+1];
        break;

        case 12:  // Two channels 32 bit. Oscilloscope raw data ch1
        if(ad_maxval1<timf1_int[p0+1])ad_maxval1=timf1_int[p0+1];
        if(ad_minval1>timf1_int[p0+1])ad_minval1=timf1_int[p0+1];
        ya=(float)(timf1_int[p0+1])/65536;
        break;

        case 13:  // Two channels 16 bit. Oscilloscope raw data ch1
        if(ad_maxval1<timf1_short_int[p0+1])ad_maxval1=timf1_short_int[p0+1];
        if(ad_minval1>timf1_short_int[p0+1])ad_minval1=timf1_short_int[p0+1];
        ya=timf1_short_int[p0+1];
        break;

        case 14:   // Two channels IQ 32 bit. Oscilloscope raw data ch1
        if(ad_maxval1<timf1_int[p0+2])ad_maxval1=timf1_int[p0+2];
        if(ad_minval1>timf1_int[p0+2])ad_minval1=timf1_int[p0+2];
        if(ad_maxval2<timf1_int[p0+3])ad_maxval2=timf1_int[p0+3];
        if(ad_minval2>timf1_int[p0+3])ad_minval2=timf1_int[p0+3];
        ya=(float)(timf1_int[p0+2])/65536;
        yb=(float)(timf1_int[p0+3])/65536;
        break;

        case 15:   // Two channels IQ 16 bit. Oscilloscope raw data ch0.
        if(ad_maxval1<timf1_short_int[p0+2])ad_maxval1=timf1_short_int[p0+2];
        if(ad_minval1>timf1_short_int[p0+2])ad_minval1=timf1_short_int[p0+2];
        if(ad_maxval2<timf1_short_int[p0+3])ad_maxval2=timf1_short_int[p0+3];
        if(ad_minval2>timf1_short_int[p0+3])ad_minval2=timf1_short_int[p0+3];
        ya=timf1_short_int[p0+2];
        yb=timf1_short_int[p0+3];
        break;

        default:
        ya=0;
        yb=0;
        break;
        }
      ch1_y[x]=ya;    
      ch2_y[x]=yb;    
      p0=(p0+p_increment)&p_max;
      x++;

/*
Trigger. Something is wrong in that sweeps sometimes
do not extend over the entire screen.

if(x == 2)
  {
  if((float)ch1_y[0]*(float)ch1_y[1] > 0)x=0;
  if(ch1_y[0] > 0)x=0;
  }
*/  
  
      if(x>=screen_width)
        {
        x=0;
        if(i==0)
          {
          show_adtest();   
          if(kill_all_flag) goto adtest_exit;
          }
        i++;
        }
      }
    }  
lir_sleep(1000000);
  if(local_adtest_new != adtest_new)
    {
    local_adtest_new=adtest_new;
    goto restart;
    }
  }
if(thread_command_flag[THREAD_RX_ADTEST]==THRFLAG_IDLE)
  {
  thread_status_flag[THREAD_RX_ADTEST]=THRFLAG_IDLE;
  while(thread_command_flag[THREAD_RX_ADTEST] == THRFLAG_IDLE)
    {
    lir_await_event(EVENT_TIMF1);
    timf1p_px=(timf1p_px+timf1_blockbytes)&timf1_bytemask;
    }
  if(thread_command_flag[THREAD_RX_ADTEST] == THRFLAG_ACTIVE)goto restart;
  }  
adtest_exit:;
thread_status_flag[THREAD_RX_ADTEST]=THRFLAG_RETURNED;
}