У меня есть чужие С-шные читалки. Я могу их сбросить. А DLL-ка так устроена, что нужно иметь и МАТЛАБовский вызов, и С-шную подпрограмму и знать некоторые особенности вызова DLL-ки. Я могу выложить и то, и другое. Но на вопросы о том, как это работает, отвечать не хочу. При попытке использования, в смысле переделки, такие вопросы обязательно возникнут. А если без переделки, то получится просто моя программа. Я ее и так могу дать.

Ну, да. Ты права.
А про разделение тем в программировании, я, все-таки, против. Мы же там будем не программы по темам писать. Это, все равно, каждый сам делать будет. А будем разговаривать про всякие случаи непонятные. Как сделать лучше то, или иное. Какой-то конкретный программистский оборот обсуждать. А где это может пригодиться, человек сам сообразит. Ну, примерно, как мы обсудили с циклами. А взять чужую читалку и прямо к себе ее применить у меня, например, никогда не получалось. Все равно придется переделывать. Ну, как минимум, выходы другие. Польза от того, что такие читалку будут у нас в одном месте лежать, да, есть. Поэтому мне и кажется, что их надо держать в одном месте, независимо от языка программирования. Взял, скопировал и переделал.

Ну, так и проблема в том, как делиться DLL-кой. Я, например,  тебе ее отдаю, а ты у нее  на входе видишь, например, такое (не поленилась, специально скопировала реальный текс):

void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
    double *time_buf, *index_buf_out;
    double  dchan, year, day_start, day_end;
    double  number_station, size;
    int     status, mrows, ncols;
    char    *input_buf;
double  *buf_out;
    int     buflen, all_count1, all_count2;
   
    if( nrhs != 5 )
    mexErrMsgTxt("Need 5 inputs required.");
    if( nlhs != 4 )
    mexErrMsgTxt("Need 4 output required.");
   
    if ( mxIsChar(prhs[0]) != 1)
      mexErrMsgTxt("1 inputs argument must be a string.");

    /* Get the length of the input string. */
    buflen = (mxGetM(prhs[0]) * mxGetN(prhs[0])) + 1;
   
    /* Allocate memory for input and output strings. */
    input_buf = mxCalloc( buflen, sizeof(char));
   
    status = mxGetString(prhs[0], input_buf, buflen);
    if(status != 0)  mexWarnMsgTxt("Not enough space. String is truncated.");
   

  /*  Create a pointer to the input argument*/
  dchan = *mxGetPr(prhs[1]);
  year = *mxGetPr(prhs[2]);
  day_start = *mxGetPr(prhs[3]);
  number_station = *mxGetPr(prhs[4]);
 
  /*  Set the output pointer to the output matrix. */
    all_count1 = (3600 * 24 * 5 + 30*60*5);
    all_count2 = (300 * 24 + 30*60);   
   
    plhs[0] = mxCreateDoubleMatrix( 1, all_count1, mxREAL);
    plhs[1] = mxCreateDoubleMatrix( 1, all_count2, mxREAL);
    plhs[2] = mxCreateDoubleMatrix( 1, all_count2, mxREAL);
 
  /*  Create a C pointer to a copy of the output matrix. */
  buf_out = mxGetPr(plhs[0]);
  index_buf_out = mxGetPr(plhs[1]);
  time_buf = mxGetPr(plhs[2]);
 
  /*  Call the C subroutine. */
  convert_AGO_Rio( input_buf, buflen, (int)dchan, (int)year, (int)day_start,
                   (int)number_station, buf_out, index_buf_out, time_buf, &size );

Этот текст не понятен ни тем кто знает С,  ни тем, кто знает МАТЛАБ. А только тем, кто озаботился, потратил 2-3 дня и понял, как устроены DLL в МАТЛАбе. Просто применить к себе ты его не сможешь, - у тебя входы и выходы другие. Получается, что эти программы бесполезны для тех, кто не знает как DLL работает.

Тогда, да. Просто я думала, что мы на форуме друг другу помогать будем разбираться. Если без объяснений, как работает именно DLL, то я не против. Я могу, помочь разобраться в С-шной программе, или МАТЛАбской. Но объяснять DLL-ку я застрелюсь.

Я сомневалась в полезности выкладки DLL, но раз ты считаешь, что выкладки без объяснений тоже полезны, то отлично. Я могу тогда выложить их всех. Займусь тогда этим постепенно.

А я уж нашла, что выложить для устрашения. Ну, тогда в качестве рекламы можно рассматривать тот список из 30 наименований. Для интересующихся может быть предоставлена любая читалка из этого списка. НО возможно это будет DLL-ка!!!!

Во, смотри и трепещи!! Читалка для чтения SPA @ MCM

%--------------------------------------
function    [out_Buff, buff_err, num_err] = Read_SPA( in_name, key, name_index )

if( key == 1 )
    out_Buff = zeros(4, 24*3600*10);
    out_Buff(1, = [0:0.1:24*3600-0.1];
    Buff_Boundary(1, = [0:1:24*3600*10-1];
    out_Buff(2, = 11;
    out_Buff(3, = 11;
    out_Buff(4, = 11;
end;
if( key == 2 )
    out_Buff = zeros(4, 24*3600);
    out_Buff(1, = [0:1:24*3600-1];
    Buff_Boundary = [];
    out_Buff(2, = 1200;
    out_Buff(3, = 1200;
    out_Buff(4, = 1200;
end;
if( key == 3 )
    out_Buff = zeros(4, 24*3600);
    out_Buff(1, = [0:1:24*3600-1];
    Buff_Boundary = [];
    out_Buff(2, = 9;
    out_Buff(3, = 9;
    out_Buff(4, = 9;
    out_Buff(5, = 9;
end;

for ( i = 0 : 23 )
    name = sprintf( '%s%02d', in_name, i );
    [ Data_H, Data_D, Data_Z, Buff_time, Data_4th_axis, count ] = convert_SPA( name, key, name_index );
        str = sprintf('count = %i', count);
        disp(str);
   
    if( count > 0 )
        if( (key == 2) | (key == 3) )  Buff_time(1, = Buff_time(1, / 10;end;
        out_Buff(2,Buff_time(1,1:count)+1) = Data_H(1,1:count);
        out_Buff(3,Buff_time(1,1:count)+1) = Data_D(1,1:count);
        out_Buff(4,Buff_time(1,1:count)+1) = Data_Z(1,1:count);
        if( key == 3 )  out_Buff(5,Buff_time(1,1:count)+1) = Data_4th_axis(1,1:count); end;
    end;

    Buff_time = [];   
    Data_H = [];   
    Data_D = [];   
    Data_Z = [];
    Data_4th_axis = [];
end;

if( key == 1 ) Cut_Val = 11; end;
if( key == 2 ) Cut_Val = 1200; end;
if( key == 3 ) Cut_Val = 9; end;
[buff_err, num_err] = Get_Boundary( Cut_Val, out_Buff, key, Buff_Boundary);
%--------------------------------------

%--------------------------------------
function    [buff_err, num_err] = Get_Boundary( Cut_Val, out_Buff, key, Buff_Boundary)

if( key == 1 )  out_Buff_temp(1, = Buff_Boundary(1,;   
else            out_Buff_temp(1, = out_Buff(1,;
end;

    num_err = 0;
   
    [i] = find(out_Buff(2, == Cut_Val );
   
    if( isempty(I) == 1 ) buff_err = []; return;end;
       
    [i,k] = size(I);
    end_Val = out_Buff_temp(1,I(k));

    n = 1;
    while( isempty(I) ~= 1 )
       
        [i,k] = size(I);
        buff_err(n) = out_Buff_temp(1,I(1));
        n = n + 1;
        t = 1;
        for( i = out_Buff_temp(1,I(1)) : out_Buff_temp(1,I(k)) )
           
            if( i ~= out_Buff_temp(1,I(t)) )
               
                buff_err(n) = i-1;
%                if( buff_err(n-1) == buff_err(n) ) t = t + 2;continue;end;
%str = sprintf('i = %i, out_Buff(1,I(t)) = %i, buff_err(n-1) =%i buff_err(n) = %i', i,out_Buff_temp(1,I(t)), buff_err(n-1), buff_err(n));
%disp(str);
%if( n > 20) return;end;
                n = n + 1;
                num_err = num_err + 1;
               
                temp = [];
                temp = I(1,t:k);
                I = [];
                I = temp;

                break;
               
            end;
           
            t = t + 1;
           
            if(out_Buff_temp(1,I(t)) >= end_Val )
                buff_err(n) = i;
                num_err = num_err + 1;
                I = [];
                break;
            end;
           
        end;   
    end;   
    str = sprintf('# error = %i; Index : ', num_err);
disp(str);
disp(buff_err);
%--------------------------------------

ВОТ СТРАШНАЯ DLL-ка к этой простой МАТЛАБовской программке:

#include "mex.h"

#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <io.h>
#include <string.h>

#define      NBYTES    4096
#define NCHANNELS 46

void Read_10Hz(int hdr_hr, int hdr_min, int hdr_sec, int hdr_hsec, int *i_data,
double *Time_Buff, double *out_buffer_H, double *out_buffer_D, double *out_buffer_Z, int data_size, short *data,
    char descriptors_10Hz[NCHANNELS], short number_channels, short missing_channels1, short missing_channels2);
void Read_1Hz(int hdr_hr, int hdr_min, int hdr_sec, int hdr_hsec, int *i_data,
double *Time_Buff, double *out_buffer_H, double *out_buffer_D, double *out_buffer_Z, int data_size, short *data,
    char descriptors_1Hz[NCHANNELS], short number_channels, short missing_channels1, short missing_channels2);
void Read_Riometer(int hdr_hr, int hdr_min, int hdr_sec, int hdr_hsec, int *i_data,
double *Time_Buff, double *out_buffer_H, double *out_buffer_D, double *out_buffer_Z, int data_size, short *data,
    char descriptors_1Hz[NCHANNELS], short number_channels, short missing_channels1, short missing_channels2, double* output_buf_4);
void convert_SPA( char *input_buf, int buflen,
    double *output_buf_H, double *output_buf_D, double *output_buf_Z, double *time_buf, double *count,
    double key, double name_index, double* output_buf_4 );

void convert_SPA( char *name, int buflen, double *out_buffer_H, double *out_buffer_D, double *out_buffer_Z, double *time_buffer, double *count, double key, double name_index, double* output_buf_4  )
{
   unsigned int    bytesread;

   int    fh;
   int    i, j, t, k, i_data, key_read, len, key_int;
   int    header_length, data_size;

   int    hdr_year, hdr_day, hdr_hr, hdr_min, hdr_sec, hdr_hsec;
   short buffer[NBYTES], *data;
   
   long    offset, pos_end;

   char    *ptr_buffer, *header_time, *descriptors, test_byte;

   short size_descriptors;

   short _100_mlhz_channels, one_hz_channels, ten_hz_channels, missing_channels1, missing_channels2;

   char    descriptors_10Hz[NCHANNELS], descriptors_1Hz[NCHANNELS], descriptors_100mHz[NCHANNELS];

   fh = _open( name, _O_BINARY , _O_RDONLY );
   
   len = strlen( name );
   test_byte = name[len-9];
//mexPrintf("\n name  = %s ", name);
//mexPrintf("\n test_byte  = %i ", test_byte);
//return;

   if( fh == -1 ) {  mexPrintf("\n not found %s\n", name); *count = -1; return;};

   pos_end = _lseek( fh, 0L, SEEK_END );
   _lseek( fh, 0L, SEEK_SET );
   
   
   key_int = (int)key;
   bytesread = 1;
   i_data = 0;
   k = 0;
   while( bytesread > 0 )
   {
again:
   
    if( k > 200 ) {*count = i_data; return;}
   
    k++;
   
    offset = _tell( fh );
    mexPrintf("\n offset = %i k = %i ", offset, k);

    if( ( bytesread = _read( fh, buffer, NBYTES ) ) <= 0 ) break;
    ptr_buffer = (char *)buffer;
    data = (short *)buffer;

    t = 0;
    for( i = 0; i < 24; i++)
    {
    if( (data[i] == -21846) & (data[i+1] == -21846) )
    {
        for( j = i; j < NBYTES; j++)
        {
        if( data[j] != -21846 ) {t = j; break;}
        }
        if( t > 0 ) break;
    }
    }
    if( t > 1 )
    {
    mexPrintf("\n Resetting AAAA t = %i i = %i k = %i", t, i, k );
       offset = NBYTES - t;
    lseek(fh, -offset, SEEK_CUR );
        goto again;
    }

    t = 0;
    for( i = 0; i < 24; i++)
    {
//mexPrintf("\n  data[i], data[i+1] : %i  %i ", data[i], data[i+1] );
    if( (data[i] == 28784) & (data[i+1] == 28784) )
    {               
        for( j = i; j < NBYTES; j++)
        {
        if( data[j] != 28784 ) {t = j; mexPrintf("\n find 7070");break;}
        }
        if( t > 0 ) break;
    }
    }
    if( t > 1 )
    {
    mexPrintf("\n Resetting 7070 t = %i i = %i ", t, i );
       offset = NBYTES - t;
    lseek(fh, -offset, SEEK_CUR );
        goto again;
    }

   if( ( ptr_buffer[0] != (char)name_index)  | (ptr_buffer[9] != test_byte-48) )
   {
    mexWarnMsgTxt("\n Error block");
mexPrintf("\n ptr_buffer[0] = %i ptr_buffer[9]= %i", ptr_buffer[0], ptr_buffer[9] );
    key_read = 0;
    for( j = 0; j < NBYTES-9; j++)
    {
//mexPrintf("\n ptr_buffer[j] = %i ptr_buffer[j+9]= %i", ptr_buffer[j], ptr_buffer[j+9]);
        if( (ptr_buffer[j] == (char)name_index) & (ptr_buffer[j+9] == test_byte-48) )//9 - 97 год
        {
        key_read = 1;
        break;
        }
               
    }
    if( key_read == 1 )
    {
        offset = NBYTES - j;
        lseek(fh, -offset, SEEK_CUR );
        key_read = 0;
    }

    goto again;
   }

//mexPrintf("\n Enter");
   header_length = ptr_buffer[1];
   data_size = buffer[1];
//mexPrintf("\n data_size - %i %i %i %i", data_size, ptr_buffer[0], ptr_buffer[1], ptr_buffer[2]);

   header_time = ptr_buffer + 9;
   hdr_year = 10*header_time[0] + header_time[1];
   hdr_day = 100*header_time[2] + 10*header_time[3] + header_time[4];
   hdr_hr = 10*header_time[5] + header_time[6];
   hdr_min = 10*header_time[7] + header_time[8];
       hdr_sec = 10*header_time[9] + header_time[10];
       hdr_hsec = header_time[11];
mexPrintf("\n hdr_hr = %i hdr_min = %i hdr_sec = %i hdr_hsec - %i ", hdr_hr, hdr_min, hdr_sec, hdr_hsec);

   descriptors = header_time + 12;
   i = 0;

       ten_hz_channels = descriptors[i];
mexPrintf("\n ten_hz_channels %i", ten_hz_channels );
   if( ten_hz_channels > 3 )  {   mexWarnMsgTxt("\nten_hz_channels > 3\n");   return;  }

       i = i + 1;
   if ( ten_hz_channels > 0 )
   {
       for( j = 0; j < ten_hz_channels; j++ )
       {
        descriptors_10Hz[j] = descriptors[i];
        i = i + 1;
       };
   };

   one_hz_channels = descriptors[i];
       i = i + 1;
       if ( one_hz_channels > 0 )
   {
       for( j = 0; j < one_hz_channels; j++ )
       {
        descriptors_1Hz[j] = descriptors[i];
        i = i + 1;
       };
   };

   _100_mlhz_channels = descriptors[i];
       i = i + 1;
   {
       for( j = 0; j < _100_mlhz_channels; j++ )
       {
        descriptors_100mHz[j] = descriptors[i];
        i = i + 1;
       };
   };

   size_descriptors = i;
//    data = (short *)(descriptors + i );
   data = (short *)(ptr_buffer + header_length );
//mexPrintf("\n data_size = %i size_descriptors = %i header_length = %i", data_size, size_descriptors, header_length);
//return;
//       offset = _tell( fh );
//       mexPrintf("\n offset = %i \n ", offset-4096);
   
    t = 0;
   
    for( i = 0; i < data_size-1; i++)
    {                   
    if( (data[i] == -21846) & (data[i+1] == -21846) )
    {
        for( j = i; j < data_size; j++)
        {
        if( data[j] != -21846 ) {t = j; break;}
        }
    }
    }
   
    if( t == 0 )
    {
    for( i = 0; i < data_size-1; i++)
    {                   
        if( (data[i] == 9167) & (data[i+1] == 9167) )
        {
        for( j = i; j < data_size; j++)
        {
            if( data[j] != 9167 ) {t = j; break;}
        }

        }
    }
    }
   
    if( t > 1 )
    {
       offset = _tell( fh );
       mexPrintf("\n error!!! offset = %i \n ", offset);
       if( offset >= pos_end ) { *count = i_data; return;}
//       offset = NBYTES - (6*2 + 5*2 + size_descriptors + t*2);
       offset = NBYTES - (header_length + t*2);
       lseek(fh, -offset, SEEK_CUR );
       mexPrintf("\n ERROR  hdr_hr = %i hdr_min = %i hdr_sec = %i hdr_hsec - %i\n ", hdr_hr, hdr_min, hdr_sec, hdr_hsec);
       mexPrintf("\n offset = %i \n ", offset);
       goto again;
    }
//if( k < 5 ) continue;
//mexPrintf("\n data[0] = %i data[0] - %i %i %i", data[0], data[1], data[2], data[3]);
//return;
    if( key_int == 1 )
    {
    missing_channels1 = one_hz_channels;
    missing_channels2 = _100_mlhz_channels;   
//mexPrintf("\n key_int == 1 missing_channels1 = %i missing_channels2 = %i data_size = %i\n", missing_channels1, missing_channels2, data_size);
    Read_10Hz(hdr_hr, hdr_min, hdr_sec, hdr_hsec, &i_data,
        time_buffer, out_buffer_H, out_buffer_D, out_buffer_Z, data_size, data,
        descriptors_10Hz, ten_hz_channels, missing_channels1, missing_channels2 );
    }

    if( key_int == 2 )
    {
    missing_channels1 = ten_hz_channels;
    missing_channels2 = _100_mlhz_channels;   
//mexPrintf("\n key_int == 2 missing_channels1 = %i missing_channels2 = %i data_size = %i\n", missing_channels1, missing_channels2, data_size);
    Read_1Hz(hdr_hr, hdr_min, hdr_sec, hdr_hsec, &i_data,
        time_buffer, out_buffer_H, out_buffer_D, out_buffer_Z, data_size, data,
        descriptors_1Hz, one_hz_channels, missing_channels1, missing_channels2);
    }

    if( key_int == 3 )
    {
    missing_channels1 = ten_hz_channels;
    missing_channels2 = _100_mlhz_channels;   
//mexPrintf("\n key_int == 3 missing_channels1 = %i missing_channels2 = %i data_size = %i\n", missing_channels1, missing_channels2, data_size);
//return;
    Read_Riometer(hdr_hr, hdr_min, hdr_sec, hdr_hsec, &i_data,
        time_buffer, out_buffer_H, out_buffer_D, out_buffer_Z, data_size, data,
        descriptors_1Hz, one_hz_channels, missing_channels1, missing_channels2, output_buf_4);
//return;
    }
    t = 0;
    for( i = data_size; i < NBYTES/2 - 1; i++)
    {
    if( (data[i] == -21846) & (data[i+1] == -21846) )
//mexPrintf("\n %i %i %i", data[i], data[i+1], i);
    {
        for( j = i; j < data_size; j++)
        {
        if( data[j] != -21846 ) {t = j; break;}
        }
    }
    }
    if( t > 1 )
    {
       offset = _tell( fh );
       mexPrintf("\n offset = %i \n ", offset);
//       offset = NBYTES - (6*2 + 5*2 + size_descriptors + t*2);
       offset = NBYTES - (header_length + data_size*2 + t*2);
       lseek(fh, -offset, SEEK_CUR );
       mexPrintf("\n ERROR  hdr_hr = %i hdr_min = %i hdr_sec = %i hdr_hsec - %i\n ", hdr_hr, hdr_min, hdr_sec, hdr_hsec);
       mexPrintf("\n offset = %i \n ", offset);
       goto again;
    }

}

   _close( fh );
*count = i_data;
}

void mexFunction( int nlhs, mxArray *plhs[],
                  int nrhs, const mxArray *prhs[] )
{
    double  *output_buf_H, *output_buf_D, *output_buf_Z, *output_buf_4;
double *time_buf, key, count, name_index;
    int     status;
    char    *input_buf, str_temp[180];
    int     buflen, all_count;
   
    if( nrhs != 3 )
    mexErrMsgTxt("Need 3 inputs required.");
    if( nlhs != 6 )
    mexErrMsgTxt("Need 6 output required.");
   
    if ( mxIsChar(prhs[0]) != 1)
      mexErrMsgTxt("1 inputs argument must be a string.");

    /* Get the length of the input string. */
    buflen = (mxGetM(prhs[0]) * mxGetN(prhs[0])) + 1;
   
    /* Allocate memory for input and output strings. */
    input_buf = mxCalloc( buflen, sizeof(char));
   
    status = mxGetString(prhs[0], input_buf, buflen);
    if(status != 0)
      mexWarnMsgTxt("Not enough space. String is truncated.");
   

  /*  Create a pointer to the input argument*/
  key = *mxGetPr(prhs[1]);
  name_index = *mxGetPr(prhs[2]);
  //day_start = *mxGetPr(prhs[3]);
  //number_station = *mxGetPr(prhs[4]);
 
  /*  Set the output pointer to the output matrix. */
    all_count = NBYTES * 65;
   
    plhs[0] = mxCreateDoubleMatrix( 1, all_count, mxREAL); //data H
    plhs[1] = mxCreateDoubleMatrix( 1, all_count, mxREAL); //data D
    plhs[2] = mxCreateDoubleMatrix( 1, all_count, mxREAL); //data Z
    plhs[3] = mxCreateDoubleMatrix( 1, all_count, mxREAL); //time
if( key == 3 )
    plhs[4] = mxCreateDoubleMatrix( 1, all_count, mxREAL); //Riometer 4-th axis
else
    plhs[4] = mxCreateDoubleMatrix( 1, 1, mxREAL);         //Non Riometer
 
  /*  Create a C pointer to a copy of the output matrix. */
  output_buf_H = mxGetPr(plhs[0]);
  output_buf_D = mxGetPr(plhs[1]);
  output_buf_Z = mxGetPr(plhs[2]);
  time_buf    = mxGetPr(plhs[3]);
  output_buf_4 = mxGetPr(plhs[4]);
 
  /*  Call the C subroutine. */
  convert_SPA( input_buf, buflen, output_buf_H, output_buf_D, output_buf_Z, time_buf, &count, key, name_index, output_buf_4 );

  plhs[5] = mxCreateDoubleMatrix( 1, 1, mxREAL );
  *mxGetPr(plhs[5]) = count;

}

void Read_10Hz(int hdr_hr, int hdr_min, int hdr_sec, int hdr_hsec, int *i_data,
double *Time_Buff, double *out_buffer_H, double *out_buffer_D, double *out_buffer_Z, int data_size, short *data,
    char descriptors_10Hz[NCHANNELS], short number_channels, short missing_channels1, short missing_channels2)
{
long bin_time;
int    i, j, key;
short *data_temp;
double scale;

scale = 10.0/32768.0;

    bin_time = hdr_hr*36000L + hdr_min*600L + hdr_sec*10L + hdr_hsec;
//mexPrintf("\n hdr_hsec = %i hdr_sec - %i ", hdr_hsec, hdr_sec);
hdr_sec  = hdr_sec - (hdr_sec/10)*10;

key = 0;
if( hdr_hsec == 0 ) key = 1;
if( (hdr_hsec == 0) & (hdr_sec == 0) ) key = 2;

data_temp = data;
i = 0;
while( i < data_size )
{
   
    out_buffer_H[*i_data] = 11;
    out_buffer_D[*i_data] = 11;
    out_buffer_Z[*i_data] = 11;
    for( j = 0; j < number_channels; j++)
    {
    if(descriptors_10Hz[j] == 1)
        out_buffer_H[*i_data] = data_temp[i] * scale * 0.365;
    if(descriptors_10Hz[j] == 2)
        out_buffer_D[*i_data] = data_temp[i] * scale * 0.365;
    if(descriptors_10Hz[j] == 45)
        out_buffer_Z[*i_data] = data_temp[i] * scale * 0.365;
    i++;
    }
    Time_Buff[*i_data] = bin_time;
    *i_data = *i_data + 1;
    bin_time = bin_time + 1;   

    if( key != 0)
    {
    if( key == 1 ) i = i + missing_channels1;
    if( key == 2 ) i = i + missing_channels1 + missing_channels2;
    key = 0;
    }

    if( hdr_hsec == 10  )
    {
    i = i + missing_channels1;
    hdr_hsec = 0;
    hdr_sec  = hdr_sec + 1;
    }
   
    if( (hdr_sec == 10) )
    {
    i = i + missing_channels2;
    hdr_sec  = 0;
    }
    hdr_hsec++;
}
}

void Read_1Hz(int hdr_hr, int hdr_min, int hdr_sec, int hdr_hsec, int *i_data,
double *Time_Buff, double *out_buffer_H, double *out_buffer_D, double *out_buffer_Z, int data_size, short *data,
    char descriptors_1Hz[NCHANNELS], short number_channels, short missing_channels1, short missing_channels2)
{
long bin_time;
int    i, j, key;
short *data_temp;
double scale;

scale = 10.0/32768.0;

    bin_time = hdr_hr*36000L + hdr_min*600L + hdr_sec*10L + hdr_hsec;
//mexPrintf("\n in start hdr_sec - %i hdr_hsec = %i", hdr_sec, hdr_hsec);
hdr_sec  = hdr_sec - (hdr_sec/10)*10;

key = 0;
if( hdr_hsec == 0 ) key = 1;
if( (hdr_hsec == 0) & (hdr_sec == 0) ) key = 2;
//mexPrintf("\n key - %i ", key );

data_temp = data;
i = 0;
while( i < data_size-1 )
{
    i = i + missing_channels1;
//    i = i + 3;

    if( hdr_hsec == 10 )
    {
    out_buffer_H[*i_data] = 1200;
    out_buffer_D[*i_data] = 1200;
    out_buffer_Z[*i_data] = 1200;

    Time_Buff[*i_data] = bin_time;
//mexPrintf("\n bin_time - %i ", bin_time );

    for( j = 0; j < number_channels; j++)
    {
        if(descriptors_1Hz[j] == 6)
        {
        out_buffer_H[*i_data] = data_temp[i] * scale * 100;
//        mexPrintf("\ni = %i data_temp[i] = %i", i, data_temp[i]);
        }
        if(descriptors_1Hz[j] == 7)
        {
        out_buffer_D[*i_data] = data_temp[i] * scale * 100;
//        mexPrintf("\ni = %i, data_temp[i] = %i", i, data_temp[i]);
        }
        if(descriptors_1Hz[j] == 8)
        {
        out_buffer_Z[*i_data] = data_temp[i] * scale * 100;
//        mexPrintf("\ni = %i data_temp[i] = %i", i, data_temp[i]);
        }
        i++;
    }
//mexPrintf("\ni = %i i_data = %i Time_Buff[*i_data] - %f H = %f", i, *i_data, Time_Buff[*i_data], out_buffer_H[*i_data] );
    *i_data = *i_data + 1;
    hdr_hsec = 0;
    hdr_sec  = hdr_sec + 1;
    }

    if( key != 0)
    {
    out_buffer_H[*i_data] = 1200;
    out_buffer_D[*i_data] = 1200;
    out_buffer_Z[*i_data] = 1200;

    Time_Buff[*i_data] = bin_time;
//mexPrintf("\n bin_time - %i ", bin_time );

    for( j = 0; j < number_channels; j++)
    {
        if(descriptors_1Hz[j] == 6)
        {
        out_buffer_H[*i_data] = data_temp[i] * scale * 100;
//        mexPrintf("\ni = %i data_temp[i] = %i", i, data_temp[i]);
        }
        if(descriptors_1Hz[j] == 7)
        {
        out_buffer_D[*i_data] = data_temp[i] * scale * 100;
//        mexPrintf("\ni = %i, data_temp[i] = %i", i, data_temp[i]);
        }
        if(descriptors_1Hz[j] == 8)
        {
        out_buffer_Z[*i_data] = data_temp[i] * scale * 100;
//        mexPrintf("\ni = %i data_temp[i] = %i", i, data_temp[i]);
        }
        i++;
    }
//mexPrintf("\ni = %i i_data = %i Time_Buff[*i_data] - %f H = %f", i, *i_data, Time_Buff[*i_data], out_buffer_H[*i_data] );
    *i_data = *i_data + 1;
   
    if( key == 2 ) i = i + missing_channels2;

    key = 0;
    }

    if( hdr_sec == 10 )
    {
    i = i + missing_channels2;
    hdr_sec  = 0;
    }
   
    bin_time = bin_time++;
    hdr_hsec++;
}
//mexPrintf("\n in end hdr_sec - %i hdr_hsec = %i", hdr_sec, hdr_hsec);
}

void Read_Riometer(int hdr_hr, int hdr_min, int hdr_sec, int hdr_hsec, int *i_data,
double *Time_Buff, double *out_buffer_H, double *out_buffer_D, double *out_buffer_Z, int data_size, short *data,
    char descriptors_1Hz[NCHANNELS], short number_channels, short missing_channels1, short missing_channels2, double* out_buffer_4)
{
long bin_time;
int    i, j, key;
short *data_temp;
double scale;

scale = 10.0/32768.0;

    bin_time = hdr_hr*36000L + hdr_min*600L + hdr_sec*10L + hdr_hsec;
//mexPrintf("\n hdr_sec - %i hdr_hsec = %i", hdr_sec, hdr_hsec);
hdr_sec  = hdr_sec - (hdr_sec/10)*10;

key = 0;
if( hdr_hsec == 0 ) key = 1;
if( (hdr_hsec == 0) & (hdr_sec == 0) ) key = 2;

data_temp = data;
i = 0;
while( i < data_size-1 )
{
    i = i + missing_channels1;

    if( hdr_hsec == 10 )
    {
    out_buffer_H[*i_data] = 9;
    out_buffer_D[*i_data] = 9;
    out_buffer_Z[*i_data] = 9;
    out_buffer_4[*i_data] = 9;

    Time_Buff[*i_data] = bin_time;

    for( j = 0; j < number_channels; j++)
    {
        if(descriptors_1Hz[j] == 3)
        out_buffer_H[*i_data] = data_temp[i] * scale;
        if(descriptors_1Hz[j] == 4)
        out_buffer_D[*i_data] = data_temp[i] * scale;
        if(descriptors_1Hz[j] == 5)
        out_buffer_Z[*i_data] = data_temp[i] * scale;
        if(descriptors_1Hz[j] == 17)
        out_buffer_4[*i_data] = data_temp[i] * scale;
        i++;
    }
//mexPrintf("\n Time_Buff[*i_data] = %f out_buffer_H[*i_data] = %f ", Time_Buff[*i_data], out_buffer_H[*i_data] );
    *i_data = *i_data + 1;
    hdr_hsec = 0;
    hdr_sec  = hdr_sec + 1;
    }

    if( key != 0)
    {
    out_buffer_H[*i_data] = 9;
    out_buffer_D[*i_data] = 9;
    out_buffer_Z[*i_data] = 9;
    out_buffer_4[*i_data] = 9;

    Time_Buff[*i_data] = bin_time;

    for( j = 0; j < number_channels; j++)
    {
        if(descriptors_1Hz[j] == 3)
        out_buffer_H[*i_data] = data_temp[i] * scale;
        if(descriptors_1Hz[j] == 4)
        out_buffer_D[*i_data] = data_temp[i] * scale;
        if(descriptors_1Hz[j] == 5)
        out_buffer_Z[*i_data] = data_temp[i] * scale;
        if(descriptors_1Hz[j] == 17)
        out_buffer_4[*i_data] = data_temp[i] * scale;
        i++;
    }
//mexPrintf("\n Time_Buff[*i_data] = %f out_buffer_H[*i_data] = %f ", Time_Buff[*i_data], out_buffer_H[*i_data] );
    *i_data = *i_data + 1;
   
    if( key == 2 ) i = i + missing_channels2;

    key = 0;
    }

    if( hdr_sec == 10 )
    {
    i = i + missing_channels2;
    hdr_sec  = 0;
    }
   
    bin_time = bin_time++;
    hdr_hsec++;
}
}