Titan2Reader: misc.c Source File

00001 /*
00002  * This file is part of Titan2Reader
00003  *
00004  * Copyright (C) 2006, Sebastien Judenherc <sebastien.judenherc@agecodagis.com>
00005  *
00006  * This program is free software; you can redistribute it and/or modify
00007  * it under the terms of the GNU General Public License as published by
00008  * the Free Software Foundation; either version 2 of the License, or
00009  * (at your option) any later version.
00010  *
00011  * This program is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  * GNU General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU General Public License
00017  * along with this program; if not, write to the Free Software
00018  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
00019  * USA
00020  *
00021  */
00022 
00023 #include <stdlib.h>
00024 #include <stdio.h>
00025 #include <time.h>
00026 #include <ctype.h>
00027 #include <errno.h>
00028 #include <unistd.h>
00029 #include <string.h>
00030 #include <sys/types.h>
00031 #include <sys/stat.h>
00032 #include <fcntl.h>
00033 
00034 #include "common.h"
00035 
00036 char previousTag[16]; 
00037 
00038 int versionWarned=0; 
00039 
00041 void CheckVersion(void)
00042 {
00043         int dataVersion;
00044         int readerVersion;
00045         void SetBuggyMykerinos(int yes);
00046         // if the station is a Mykerinos-T
00047         if ((HWConfig.digitizer.adcFrequency==250)||(HWConfig.digitizer.adcFrequency==160))
00048         // then
00049         {
00050                 // compute dataVersion
00051                 dataVersion=(HWConfig.formatVersion<<16)+
00052                         (HWConfig.formatMajor<<8)+
00053                         HWConfig.formatMinor;
00054                 // if the Osiris version is buggy (before 2.2.4)
00055                 if (dataVersion<((2<<16)+(2<<8)+4))
00056                 // then
00057                 {
00058                         // set the bug flag
00059                         SetBuggyMykerinos(1);
00060                 }
00061                 // else
00062                 else
00063                 {
00064                         // unset the bug flag
00065                         SetBuggyMykerinos(0);
00066                 // endif
00067                 }
00068         }
00069         // else
00070         else
00071         {
00072                 // unset the bug flag
00073                 SetBuggyMykerinos(0);
00074         // endif
00075         }
00076                 
00077         // if not yet warned
00078         if (versionWarned==0)
00079         // then
00080         {
00081                 // compute dataVersion
00082                 dataVersion=(HWConfig.formatVersion<<16)+
00083                         (HWConfig.formatMajor<<8)+
00084                         HWConfig.formatMinor;
00085                 // compute readerVersion=VERSION<<16+MAJOR<<8+MINOR
00086                 readerVersion=(VERSION<<16)+(MAJOR<<8)+MINOR;
00087                 // if dataVersion>readerVersion
00088                 if (dataVersion>readerVersion)
00089                 {
00090                         // issue a warning
00091                         PrintWarning("this version of rtitan2 is older than "
00092                                         "the writer of the data. Some features may "
00093                                         "miss, please update the reader\n");
00094                         versionWarned=1;
00095                 // endif
00096                 }
00097         }
00098 }
00099 
00104 unsigned char ProcessMiscFrame(const unsigned char *frame)
00105 {
00106         int ch,i,t;
00107         int32_t tmp32;
00108         if (frame[10]!=0)
00109         {
00110                 PrintWarning("MBZ not zero in misc frame %s\n",
00111                                 StrFrame(frame));
00112                 //return(0);
00113         }
00114         switch (frame[9])
00115         {
00116                 case 0: // inst position, horiz
00117                         HWConfig.instantPos.lat=(float)(frame2i32(frame,0))*180.e-8/MY_PI;
00118                         HWConfig.instantPos.lon=(float)(frame2i32(frame,4))*180.e-8/MY_PI;
00119                         break;
00120                 case 1: // inst position, elevation
00121                         HWConfig.instantPos.elev=(float)(frame2i32(frame,0))*0.01;
00122                         break;
00123                 case 2: // inst position, Nsat
00124                         HWConfig.satelliteNumber=frame[0]&0xff;
00125                         break;
00126                 case 3: // ADC a digit info
00127                         HWConfig.digitizer.ok=1;
00128                         HWConfig.digitizer.adcFrequency=frame[0]&0xff;
00129                         HWConfig.digitizer.adcFrequency<<=8;
00130                         HWConfig.digitizer.adcFrequency+=frame[1]&0xff;
00131                         HWConfig.digitizer.adcFrequency<<=8;
00132                         HWConfig.digitizer.adcFrequency+=frame[2]&0xff;
00133 
00134                         HWConfig.digitizer.adcDecimation=(int)(frame[3]&0xff);
00135 
00136                         HWConfig.digitizer.adcDecimationLength=frame[4]&0xff;
00137                         HWConfig.digitizer.adcDecimationLength<<=8;
00138                         HWConfig.digitizer.adcDecimationLength+=frame[5]&0xff;
00139 
00140                         HWConfig.digitizer.adcId=(int)(frame[6]&0xff);
00141 
00142                         HWConfig.digitizer.secondDecimationLength=frame[7]&0xff;
00143                         HWConfig.digitizer.secondDecimationLength<<=8;
00144                         HWConfig.digitizer.secondDecimationLength+=frame[8]&0xff;
00145                         break;
00146                 case 4: // ADC constant delay
00147                         if (frame[6]!=HWConfig.digitizer.adcId)
00148                         {
00149                                 PrintError("inconsistent ADC ID: MISC3:%d MISC4:%d\n",
00150                                                 HWConfig.digitizer.adcId,
00151                                                 frame[6]&0xff);
00152                         }
00153                         HWConfig.digitizer.adcDelay=
00154                                 (float)frame2i24(frame,0)+
00155                                 (float)(frame2i24(frame,3))/(float)(1<<24);
00156                         break;
00157                 case 5: // channel description
00158                         ch=frame[0]&0xff;
00159                         if ((ch>=MAX_OSIRIS_CHANNEL)||(ch<0))
00160                         {
00161                                 PrintError("invalid channel number in MISC5: %s\n",
00162                                                 StrFrame(frame));
00163                                 break;
00164                         }
00165                         HWConfig.networkName[0]=frame[1];
00166                         HWConfig.networkName[1]=frame[2];
00167                         HWConfig.networkName[2]=0;
00168                         HWConfig.channelName[ch][0]=frame[3];
00169                         HWConfig.channelName[ch][1]=frame[4];
00170                         HWConfig.channelName[ch][2]=frame[5];
00171                         HWConfig.channelName[ch][3]=0;
00172                         HWConfig.locationName[ch][0]=frame[6];
00173                         HWConfig.locationName[ch][1]=frame[7];
00174                         HWConfig.locationName[ch][2]=0;
00175                         break;
00176                 case 6: // input stage
00177                         HWConfig.LSB=1e-3*(float)frame2i24(frame,0); //nV
00178                         HWConfig.impedance=(float)frame2i24(frame,3);
00179                         HWConfig.gain[1]=(int32_t)(frame[6]&0xff);
00180                         HWConfig.gain[2]=(int32_t)(frame[7]&0xff);
00181                         HWConfig.gain[3]=(int32_t)(frame[8]&0xff);
00182                         break;
00183                 case 7: // selected gains
00184                         for (t=0; t<8; t++)
00185                         {
00186                                 for (i=0; i<3; i++)
00187                                 {
00188                                         HWConfig.selectedGain[t*3+i]=
00189                                                 (int32_t)((frame[t]>>(2*i))&3);
00190                                 }
00191                         }
00192                         break;
00193                 case 8: // clock tuning
00194                         HWConfig.tune.clockMode=(int)(frame[0]&0xff);
00195                         HWConfig.tune.clockState=(int)(frame[1]&0xff);
00196                         HWConfig.tune.step=(int)*(((signed char*)frame)+2);
00197                         tmp32=frame2i16(frame,4); tmp32<<=16; tmp32>>=16;
00198                         HWConfig.tune.drift=1.e-3*(float)tmp32;
00199                         tmp32=frame2i16(frame,6); tmp32<<=16; tmp32>>=16;
00200                         HWConfig.tune.phase=(float)tmp32;
00201                         break;
00202                 case 9: // HP config
00203                         i=frame[0]&0xff;
00204                         if ((i<0)||(i>5))
00205                         {
00206                                 PrintError("incorrect channel index\n");
00207                                 break;
00208                         }
00209                         HWConfig.HPFilter[i*4+0]=(int32_t)frame2i16(frame,1);
00210                         HWConfig.HPFilter[i*4+1]=(int32_t)frame2i16(frame,3);
00211                         HWConfig.HPFilter[i*4+2]=(int32_t)frame2i16(frame,5);
00212                         HWConfig.HPFilter[i*4+3]=(int32_t)frame2i16(frame,7);
00213                         break;
00214                 case 10: // tag (ProcessDataFrame makes the tag empty)
00215                         memcpy(currentTag,frame,8);
00216                         currentTag[8]=0;
00217                         if (onlyTag[0]!=0)
00218                         {
00219                                 if (strcmp(currentTag,previousTag))
00220                                 {
00221                                         PrintLog("TAG '%-8s': %s [%s @ %d]\n",
00222                                                         currentTag,
00223                                                         StrTimeNS(&currentTime),
00224                                                         currentFile,
00225                                                         SafeFtell(titan2File));
00226                                         strcpy(previousTag,currentTag);
00227                                 }
00228                         }
00229                         //PrintError("tag=%s/%s\n",currentTag,onlyTag);
00230                         break;
00231                 case 11: // internal env. parameters
00232                         SetAuxChannel2(POWERSUPPLY_CHANNEL,
00233                                         (int32_t)(0.7876171875*(float)frame[0])); // 0.1V
00234                         SetAuxChannel2(TEMPERATURE_CHANNEL,
00235                                         (int32_t)(-2731.5+(float)frame2i16(frame,1))); // 0.1deg
00236 
00237                         /*
00238                         PrintDebug("V=%5.1f T=%5.1f\n",
00239                                         20.163*(float)(frame[0])/256.,
00240                                         -273.15+0.1*(float)frame2i16(frame,1));
00241                                         */
00242                         break;
00243                 case 255: // version number
00244                         HWConfig.formatVersion=(int32_t)(frame[0]&0xff);
00245                         HWConfig.formatMajor=(int32_t)(frame[1]&0xff);
00246                         HWConfig.formatMinor=(int32_t)(frame[2]&0xff);
00247                         CheckVersion();
00248                         break;
00249         }
00250         return(0);
00251 }