daily pastebin goal
53%
SHARE
TWEET

Untitled

a guest Dec 14th, 2018 56 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. # include <string>
  2. # include <iostream>
  3. #include <libsocket/exception.hpp>
  4. #include <libsocket/unixclientstream.hpp>
  5. #include <unistd.h>
  6. #include <chrono>
  7. #include "json.hpp"
  8. #include <complex>
  9. #include <fstream>
  10. #include <math.h>
  11. # include <csignal>
  12.  
  13. #define DEBUG
  14. #define RMSHALF_LENGHT  24
  15. #define WAVEFORM_LENGHT  2048
  16. #define CHANNELS_NUMBER  7
  17. #define BUFFER_SIZE 500000UL
  18.  
  19. using namespace std;
  20. using namespace nlohmann;
  21. using libsocket::unix_stream_client;
  22. using std::string;
  23.  
  24.  
  25. /*  [MessagePackObject]
  26.     public class ProtocolStructTemplate
  27.     {
  28.         [Key("BID")]
  29.         public UInt16 BlockNumber;
  30.  
  31.         [Key("Time")]
  32.         public UInt64 TimeStamp;
  33.  
  34.         [Key("Hz")]
  35.         public Single Frequency;
  36.  
  37.         [Key("CH")]
  38.         public ProtocolChannelTemplate[] Channels;
  39.     }
  40.  
  41.     [MessagePackObject]
  42.     public class ProtocolChannelTemplate
  43.     {
  44.         [Key("RMS12")]
  45.         public Single RMS12; // Valor RMS 12 ciclos: float, 4 bytes;
  46.  
  47.         [Key("THD12")]
  48.         public Single THD12; // Valor THD 12 ciclos: float, 4 bytes;
  49.  
  50.         [Key("RMSH")]
  51.         public Single[] RMSHalf; // 24 valores RMS de ½ ciclo: float, 4 bytes cada;
  52.         // Dados da forma de onda
  53.         [Key("Wave")]
  54.         public UInt16[] Waveform; //  Forma de onda: array de 2048 x 2 bytes para cada canal;
  55.         // Dados de FFT após dizimação
  56.         [Key("FFTIndex")]
  57.         public UInt16[] FFTIndex; // N índices: inteiro, 2 bytes * N;
  58.         [Key("FFTR")]
  59.         public Single[] FFTReal; // N valores reais: float, 4 bytes * N;
  60.         [Key("FFTI")]
  61.         public Single[] FFTImaginary; // N valores imaginários: float, 4 bytes * N.
  62.     }
  63. */
  64.  
  65. struct Channel
  66. {
  67.     float RMS12;
  68.     float THD12;
  69.     uint16_t RMSHSize;
  70.     float *RMSH;
  71.  
  72.     int16_t WaveformSize;
  73.     int16_t *Waveform;
  74.  
  75.     uint16_t FFTSize;
  76.     uint16_t *FFTIndex;
  77.     float *FFTReal;
  78.     float *FFTImaginary;
  79. };
  80.  
  81. struct Protocol
  82. {
  83.     uint16_t BlockID;
  84.     uint64_t TimeStamp;
  85.     float Frequency;
  86.     struct Channel Channels[CHANNELS_NUMBER];
  87.     ulong deltaTime;
  88.     int operationMode;   //0-registro, 1-adaptativos, 2-cálculos          
  89.     int OperationOption; //0-detalhe, 1-normal, 2-mínimo, 3-custo1, 4-custo2, 5-custo3, 6-qualidade/custo
  90.     float ThresholdVoltage;
  91.     float ThresholdCurrent;
  92.     uint16_t QualimetroID; 
  93. } ProtocolData;
  94.  
  95. vector<uint16_t> FFTIndex[CHANNELS_NUMBER];
  96. vector<float> FFTReal[CHANNELS_NUMBER];
  97. vector<float> FFTImag[CHANNELS_NUMBER];
  98. vector<int16_t> Waveform[CHANNELS_NUMBER];
  99. vector<float> RMSH[CHANNELS_NUMBER];
  100. vector<float> Calibration[CHANNELS_NUMBER];
  101.  
  102. unix_stream_client *Socket;
  103.  
  104. const int MAX_SPARSE_SIZE = 256;
  105. const int N_CHAN = 7;
  106. const int VECTOR_SIZE = 1024;
  107. const int MAX_SIZE = 682; //4096 (amostras) / 6 (bytes, tamanho da FFT no arquivo para cada raia - index, real e imag)
  108.  
  109. int num_of_bins_changed[N_CHAN];
  110. int c = 0;
  111. int w = 5; //quantas amostras para esquerda e direita
  112. float m = (0.1/100.0); //delta em amplitude
  113.  
  114. complex<float> Ref[N_CHAN][VECTOR_SIZE];
  115. float magRef[N_CHAN][VECTOR_SIZE];
  116. complex<float> New[N_CHAN][VECTOR_SIZE];
  117. float magNew[N_CHAN][VECTOR_SIZE];
  118. float maxMagnitude;
  119. int16_t RefWave[4][WAVEFORM_LENGHT];
  120.  
  121. int16_t indexChanged[N_CHAN][MAX_SIZE];
  122.  
  123. float epsilon_perc = 0.0001;     // percentual da raia máxima abaixo da qual as raias são zeradas
  124. float maximo_erro_perc = 0.005;  // máximo erro percentual permitido
  125.  
  126. bool fixed_ratio = false;
  127. bool reference_fft = false;
  128. bool reference_current = false;
  129. int no_change = 0;
  130. uint16_t last_block = 0;
  131. bool create_file = true;
  132. bool flag_finish = false;
  133. bool flag_shutdown = false;
  134.  
  135. uint32_t segmento;
  136. uint32_t aquisicao;
  137. string path = "/media/extern/CompressionFiles/";
  138. string pathDebug = "/media/extern/CompressionFiles/Debug/";
  139.  
  140. //arquivos de compressão
  141. std::ofstream comp_file_v1;
  142. std::ofstream comp_file_v2;
  143. std::ofstream comp_file_v3;
  144. std::ofstream comp_file_i1;
  145. std::ofstream comp_file_i2;
  146. std::ofstream comp_file_i3;
  147. std::ofstream comp_file_in;
  148. std::ofstream comp_atual;
  149. std::ofstream timestamp_file;
  150.  
  151. //arquivos para debug das formas de onda
  152. std::ofstream wave_file_v1;
  153. std::ofstream wave_file_v2;
  154. std::ofstream wave_file_v3;
  155. std::ofstream wave_file_i1;
  156. std::ofstream wave_file_i2;
  157. std::ofstream wave_file_i3;
  158. std::ofstream wave_file_in;
  159. std::ofstream wave_file;
  160. std::ofstream timestamp_aux;
  161.  
  162. int compression(struct Protocol &CompressionData);
  163. void my_qsort(void *base, uint16_t *base_idx, uint16_t nmemb);
  164. inline static void swap_int(uint16_t *src, uint16_t *dest);
  165. inline static void swap_float(float *src, float *dest);
  166. void selectFile();
  167. void changeFile();
  168.  
  169. void int_handler(int x)
  170. {
  171.     // Setal flag para finalizar arquivo no próximo processamento de bloco
  172.     flag_shutdown = true;  
  173.    
  174. }
  175.  
  176. int main(void)
  177. {
  178.     signal(SIGINT, int_handler);   // Registra evento para tratar sinal
  179.     signal(SIGQUIT, int_handler);
  180.     signal(SIGHUP, int_handler);
  181.     signal(SIGTERM, int_handler);
  182. //  signal(SIGKILL, int_handler);
  183.    
  184.     string path = "/tmp/protocol.sock";
  185.    
  186.     // Ler arquivo json para obter informações da aquisição e do segmento
  187.     json j;  // cria objeto json
  188.     std::ifstream i("/home/ubuntu/compression/compression.json");   //Usar try e catch neste segmento caso não houver arquivo ou seu conteúdo for vazio.
  189.     i >> j;
  190.     aquisicao = j["aquisicao"].get<uint32_t>();
  191.     segmento = j["segmento"].get<uint32_t>();
  192.     i.close();  // Fecha Arquivo
  193.    
  194.     cout << "Aquisicao: " << aquisicao << endl;
  195.     cout << "Segmento: " << segmento << endl;
  196.    
  197.     char *answer = new char[BUFFER_SIZE];
  198.  
  199. INIT:
  200.     try
  201.     {
  202.         Socket = new unix_stream_client(path);
  203.     }
  204.     catch (const libsocket::socket_exception& exc)
  205.     {
  206.         std::cerr << exc.mesg;
  207.    std::cout << "Retryng reconnection " << std::endl;
  208.    sleep(1);
  209.    goto INIT;
  210.     }
  211.  
  212.     while (true)
  213.     {
  214.  
  215.         usleep(1000);
  216.         int size;
  217.         try
  218.         {
  219.             size = Socket->rcv(answer, BUFFER_SIZE);
  220.         }
  221.         catch (const std::exception&)
  222.         {
  223.            
  224.         }
  225.        
  226.     if(size==0) {
  227.       sleep(1);
  228.       std::cout << "Retryng reconnection " << std::endl;
  229.       goto INIT;
  230.     }
  231.  
  232. #ifdef DEBUG
  233.         cout << "Bytes: " << size << endl;
  234.         auto start = std::chrono::high_resolution_clock::now();
  235. #endif
  236.  
  237.    
  238.    
  239.         std::vector<char> vec(answer, answer + size);
  240.  
  241.         json protocol;
  242.  
  243.         try
  244.         {
  245.             usleep(1000);
  246.             protocol = json::from_msgpack(vec);
  247.  
  248.             if (protocol.is_object())
  249.             {
  250.                 try
  251.                 {
  252.                     ProtocolData.BlockID = protocol["BID"].get<uint16_t>();
  253.                     ProtocolData.TimeStamp = protocol["Time"].get<uint64_t>();
  254.                     ProtocolData.Frequency = protocol["Hz"].get<float>();
  255.                     ProtocolData.QualimetroID = protocol["QID"].get<uint16_t>();
  256.  
  257.                     json channels = protocol["CH"];
  258.                     uint8_t channelsNumber = channels.size();
  259.  
  260.                     for (uint8_t i = 0; i < channelsNumber; i++)
  261.                     {
  262.                         json currentChannel = channels[i];
  263.  
  264.                         //ProtocolData.Channels[i].RMS12 = currentChannel["RMS12"].get<float>();
  265.                         //ProtocolData.Channels[i].THD12 = currentChannel["THD12"].get<float>();
  266.  
  267.                         //RMSH[i] = currentChannel["RMSH"].get<vector<float>>();
  268.                         //ProtocolData.Channels[i].RMSHSize = RMSH[i].size();
  269.                         //ProtocolData.Channels[i].RMSH = RMSH[i].data();
  270.  
  271.                         json Wave = currentChannel.at("Wave");
  272.  
  273.                         if (!Wave.is_null())
  274.                         {
  275.                             Waveform[i] = Wave.get<vector<int16_t>>();
  276.                             ProtocolData.Channels[i].WaveformSize = Waveform[i].size();
  277.                             ProtocolData.Channels[i].Waveform = Waveform[i].data();
  278.                         }
  279.                         else
  280.                         {
  281.                             ProtocolData.Channels[i].WaveformSize = 0;
  282.                         }
  283.  
  284.                         json FFT = currentChannel.at("FFTIndex");
  285.  
  286.                         if (!FFT.is_null())
  287.                         {
  288.                             FFTIndex[i] = FFT.get<vector<uint16_t>>();
  289.                             ProtocolData.Channels[i].FFTSize = FFTIndex[i].size();
  290.  
  291.                             ProtocolData.Channels[i].FFTIndex = FFTIndex[i].data();
  292.  
  293.                             FFTReal[i] = currentChannel["FFTR"].get<vector<float>>();
  294.                             ProtocolData.Channels[i].FFTReal = FFTReal[i].data();
  295.  
  296.                             FFTImag[i] = currentChannel["FFTI"].get<vector<float>>();
  297.                             ProtocolData.Channels[i].FFTImaginary = FFTImag[i].data();
  298.                         }
  299.                         else
  300.                         {
  301.                             ProtocolData.Channels[i].FFTSize = 0;
  302.                         }
  303.                        
  304.                         Calibration[i] = protocol["CL"].get<vector<float>>();
  305.                     }
  306.                     ProtocolData.operationMode = protocol["OM"].get<int>();
  307.                     ProtocolData.OperationOption = protocol["OO"].get<int>();
  308.                     ProtocolData.ThresholdVoltage = protocol["THV"].get<float>();
  309.                     ProtocolData.ThresholdCurrent = protocol["THI"].get<float>();
  310.                     ProtocolData.deltaTime = protocol["DT"].get<ulong>();
  311.  
  312.                     compression(ProtocolData);
  313.  
  314. #ifdef DEBUG
  315.  
  316.                     auto elapsed = std::chrono::high_resolution_clock::now() - start;
  317.                     long long microseconds = std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count();
  318.                     cout << "Processing time: " << microseconds << " us" << endl;
  319.                     cout << "-------------------\n";
  320. #endif
  321.                 }
  322.                 catch (const std::exception&)
  323.                 {
  324.                     cout << "Parsing Error" << endl;
  325.                 }
  326.             }
  327.             else
  328.             {
  329.                 cout << "Parsing Error" << endl;
  330.             }
  331.         }
  332.         catch (const std::exception&)
  333.         {
  334.         }
  335.     }
  336.     return 0;
  337. }
  338.  
  339. //******************************************************************************
  340. // Troca valores em ponto flutuante
  341. //------------------------------------------------------------------------------
  342. inline static void swap_float(float *src, float *dest)
  343. {
  344.     float temp = *src;
  345.     *src  = *dest;
  346.     *dest = temp;
  347. }
  348.  
  349. //******************************************************************************
  350. // Troca valores inteiros
  351. //------------------------------------------------------------------------------
  352.  
  353. inline static void swap_int(uint16_t *src, uint16_t *dest)
  354. {
  355.     int temp = *src;
  356.     *src = *dest;
  357.     *dest = temp;
  358. }
  359.  
  360. //******************************************************************************
  361. //  Realiza Quicksort
  362. //------------------------------------------------------------------------------
  363.  
  364. void my_qsort(void *base, uint16_t *base_idx, uint16_t nmemb)
  365. {
  366.     uint16_t  *basep = (uint16_t *)base; /* POINTER TO ARRAY OF ELEMENTS */
  367.     uint16_t  *basei = base_idx; /* POINTER TO ARRAY OF ELEMENTS */
  368.     uint16_t  i = 0; /* left scan index  */
  369.     uint16_t  j = 2 * (nmemb - 1); /* right scan index */
  370.     uint16_t  pivot = nmemb & 0xFFFE; /* Want closest even value */
  371.     uint16_t  *pivp = basep + pivot;
  372.  
  373.     if (nmemb <= 1) return;
  374.  
  375.     while (i < j)
  376.     {
  377.         while (*(float*)(basep + i) > *(float*)pivp) i = i + 2;
  378.         while (*(float*)(basep + j) < *(float*)pivp) j = j - 2;
  379.  
  380.         if (i < j)
  381.         {
  382.             swap_float((float*)(basep + i), (float*)(basep + j));
  383.             swap_int((uint16_t*)(basei + (i >> 1)), (uint16_t*)(basei + (j >> 1)));
  384.  
  385.             if (pivot == i) { pivot = j; pivp = basep + pivot; }
  386.             else if (pivot == j) { pivot = i; pivp = basep + pivot; }
  387.             i = i + 2; j = j - 2;
  388.         }
  389.         else if (i == j) { i = i + 2; j = j - 2; break; }
  390.     }
  391.  
  392.     if (j > 0) my_qsort(basep, basei, (j >> 1) + 1);
  393.     if ((i >> 1) < nmemb - 1) my_qsort(basep + i, basei + (i >> 1), nmemb - (i >> 1));
  394. }
  395.  
  396. //******************************************************************************
  397. //  Zera vetor full
  398. //------------------------------------------------------------------------------
  399. void clear_full_vector(complex <float> * vetor)
  400. {
  401.     for (int i = 0; i < VECTOR_SIZE; i++)
  402.     {
  403.         vetor[i] = 0.0;
  404.     }
  405. }
  406.  
  407. //******************************************************************************
  408. //  Cria vetor full a partir dos vetores recebidos pelo protocolo
  409. //------------------------------------------------------------------------------
  410. void create_full_vector(complex <float> * vetor, float real_full_vector[], float img_full_vector[], uint16_t ind[], uint16_t size)
  411. {
  412.     clear_full_vector(vetor);
  413.     for (int i = 0; i < size; i++)
  414.     {
  415.         vetor[ind[i]] = complex <float>(real_full_vector[i], img_full_vector[i]);
  416.     }      
  417. }
  418.    
  419. //******************************************************************************
  420. //  Calcula valor rms
  421. //------------------------------------------------------------------------------
  422. float rmsf(float vetor[])
  423. {
  424.     float rms = 0;
  425.     float reg;
  426.    
  427.     for (int j = 0; j < VECTOR_SIZE; j++)
  428.     {
  429.         rms += vetor[j] * vetor[j];
  430.     }
  431.     reg = sqrtf(rms);
  432.     return reg;
  433. }
  434.  
  435. //******************************************************************************
  436. //  Compressão, retorna número de raias que mudaram
  437. //------------------------------------------------------------------------------
  438. int compress_diff(complex <float> * ref_vector, complex <float> * new_vector, int16_t * index)
  439. {
  440.     float maximo_erro;
  441.     float erro, errot, sub;
  442.    
  443.     //vetor dif completo
  444.     float Diff_full[VECTOR_SIZE];
  445.     //variáveis vetor dif esparso
  446.     float diff[VECTOR_SIZE];
  447.     uint16_t diffIndex[VECTOR_SIZE];
  448.     uint16_t sizeDiff;
  449.    
  450.     //calcular diferença entre Ref e New
  451.     for(int i = 0 ; i < VECTOR_SIZE ; i++)
  452.     {
  453.         complex<float> dif = ref_vector[i] - new_vector[i];    
  454.         Diff_full[i] = abs(dif);           
  455.     }
  456.    
  457.     //zerar vetor diff
  458.     sizeDiff = 0;
  459.     for (int i = 0; i < VECTOR_SIZE; i++)
  460.     {
  461.         diff[i] = 0;
  462.     }
  463.    
  464.     //Preencher vetor diff apenas com os valores que não estão zerados
  465.     for(int i = 0 ; i < VECTOR_SIZE ; i++)
  466.     {
  467.         if (Diff_full[i])
  468.         {
  469.             diff[sizeDiff] = Diff_full[i];
  470.             diffIndex[sizeDiff] = i;
  471.             sizeDiff++;
  472.         }
  473.     }  
  474.    
  475.     // Realiza Quicksort
  476.     my_qsort(diff, diffIndex, sizeDiff);
  477.        
  478.     if (!fixed_ratio) // sem taxa fixa
  479.     {  
  480.         maximo_erro = maxMagnitude * maximo_erro_perc; 
  481.         erro = rmsf(Diff_full);
  482.    
  483.         if (erro < maximo_erro)
  484.             return 0;
  485.    
  486.         errot = erro;
  487.    
  488.         for (int j = 0; j < MAX_SIZE; j++)
  489.         {
  490.             ref_vector[diffIndex[j]] = new_vector[diffIndex[j]];
  491.             sub = Diff_full[diffIndex[j]];
  492.             errot = sqrtf(errot * errot - sub * sub);
  493.        
  494.             //guardar qual o índica que foi alterado
  495.             index[j] = diffIndex[j];
  496.             //cout << "Ind: " << index[j] << endl;
  497.        
  498.             if(errot < maximo_erro)
  499.                 return j;
  500.         }
  501.    
  502.         return -1;
  503.     }
  504.     else //com taxa fixa
  505.     {
  506.         for (int j = 0; j < MAX_SIZE; j++)
  507.         {
  508.             ref_vector[diffIndex[j]] = new_vector[diffIndex[j]];
  509.             sub = Diff_full[diffIndex[j]];
  510.            
  511.             //guardar qual o índica que foi alterado
  512.             index[j] = diffIndex[j];
  513.         }
  514.         return MAX_SIZE;
  515.     }
  516. }
  517.  
  518. //******************************************************************************
  519. //  Compressão, diferença da forma de onda
  520. //------------------------------------------------------------------------------
  521. int compress_waveform(int16_t * ref_wave, int16_t * new_wave)
  522. {
  523.     float excursao = 0;
  524.     float limtop[WAVEFORM_LENGHT];
  525.     float limbot[WAVEFORM_LENGHT];
  526.     float lsup[WAVEFORM_LENGHT];
  527.     float linf[WAVEFORM_LENGHT];
  528.     int indleft = 0;
  529.     int indright = 0;
  530.     float metrica = 0;
  531.    
  532.     //calcular média da referência
  533.     for (int i = 0; i < WAVEFORM_LENGHT-1; i++)
  534.     {
  535.         excursao += abs(ref_wave[i + 1] - ref_wave[i]);
  536.     }  
  537.    
  538.     metrica = m * excursao;
  539.    
  540.     for (int i = 0; i < WAVEFORM_LENGHT; i++)
  541.     {
  542.         limtop[i] = ref_wave[i] + metrica;
  543.         limbot[i] = ref_wave[i] - metrica ;
  544.     }
  545.    
  546.     //calcular limites
  547.     for (int i = 0; i < WAVEFORM_LENGHT; i++)
  548.     {
  549.         //encontrar limite da esquerda
  550.         if (i - w > 0)
  551.             indleft = i - w;
  552.         else
  553.             indleft = 0;
  554.        
  555.         //encontrar limite da direita
  556.         if(i + w < WAVEFORM_LENGHT)
  557.             indright = i + w;
  558.         else
  559.             indright = WAVEFORM_LENGHT-1;
  560.        
  561.         //encontrar máximo no intervalo
  562.         float maximo = limtop[indleft];
  563.         for (int j = indleft; j < indright+1; j++)
  564.         {
  565.             if (limtop[j] > maximo)
  566.                 maximo = limtop[j];
  567.         }              
  568.        
  569.         //encontrar mínimo no intervalo
  570.         float minimo = limbot[indleft];
  571.         for (int j = indleft; j < indright+1; j++)
  572.         {
  573.             if (limbot[j] < minimo)
  574.                 minimo = limbot[j];
  575.         }  
  576.        
  577.         lsup[i] = maximo;
  578.         linf[i] = minimo;
  579.     }
  580.    
  581.     //condições de violação
  582.     //verificar se algum valor da referência é maior que lsup, ou menor que linf
  583.     //se não for, o sinal novo é cópia suficiente da referência
  584.     //caso contrário, enviar forma de onda completa
  585.     for (int i = 0; i < WAVEFORM_LENGHT; i++)
  586.     {
  587.         if (new_wave[i] > lsup[i])
  588.             return 0;
  589.        
  590.         if (new_wave[i] < linf[i])
  591.             return 0;
  592.     }
  593.    
  594.     return 1;
  595.    
  596. }
  597.  
  598. int16_t onda[WAVEFORM_LENGHT];
  599. int16_t blockNumber = 0;  //1 a 1500 em cada arquivo
  600. bool flag_save_waveform = true;
  601.  
  602. const std::string currentDateTime() {
  603.     time_t     now = time(0);
  604.     struct tm  tstruct;
  605.     char       buf[80];
  606.     tstruct = *localtime(&now);
  607.     strftime(buf, sizeof(buf), "%d-%m-%Y.%X", &tstruct);
  608.  
  609.     return buf;
  610. }
  611.  
  612. //******************************************************************************
  613. //  Encontra diferenças entre referência e novo e gera arquivo de compressão
  614. //------------------------------------------------------------------------------
  615. int compression(struct Protocol &CompressionData)
  616. {  
  617.     blockNumber++;
  618.    
  619.     if (flag_finish)
  620.         blockNumber += 3000;
  621.    
  622.     cout << "Packet ID: " << blockNumber << endl;
  623.     cout << "Frequency: " << CompressionData.Frequency << endl;
  624.     cout << "TimeStamp: " << CompressionData.TimeStamp << endl;
  625.     cout << "Delta Time: " << CompressionData.deltaTime << endl;
  626.    
  627.     cout << "Operation mode: " << CompressionData.operationMode << endl;
  628.     cout << "Operation option: " << CompressionData.OperationOption << endl;
  629.     cout << "Threshold voltage: " << CompressionData.ThresholdVoltage << endl;
  630.     cout << "Threshold current: " << CompressionData.ThresholdCurrent << endl;
  631.        
  632.     //cout << "currentDateTime()=" << currentDateTime() << endl;
  633.    
  634.     if (!reference_fft) //se o sistema ainda não tem referência
  635.     {
  636.         reference_fft = true;
  637.        
  638.         //zerar referência no início
  639.         for(int j = 0 ; j < CHANNELS_NUMBER ; j++)
  640.         {
  641.             for (int i = 0; i < VECTOR_SIZE; i++)
  642.             {
  643.                 Ref[j][i] = 0;
  644.                 magRef[j][i] = 0;
  645.             }          
  646.         }
  647.     }
  648.    
  649.     //Transformar timestamp para string
  650.     ostringstream ostr;
  651.     ostr << CompressionData.TimeStamp;
  652.     string timestampString = ostr.str();
  653.    
  654.     //Criar arquivos
  655.     if(create_file)
  656.     {          
  657.         create_file = false;   
  658.        
  659.         cout << "Gerar arquivos" << endl;
  660.         cout << "currentDateTime()=" << currentDateTime() << endl;
  661.        
  662.         segmento++;
  663.        
  664.         char s[25];
  665.         sprintf(s, ".%07d.%07d", aquisicao, segmento);
  666.         cout << s << endl;
  667.        
  668.         char q[5];
  669.         sprintf(q, "%03d", ProtocolData.QualimetroID);
  670.         cout << "Qualimetro: " << q << endl;
  671.                            
  672.         comp_file_v1.open(path + timestampString + s + ".01." + q + ".bin", ios::binary | ios::app);       //arquivo compressao
  673.         comp_file_v2.open(path + timestampString + s + ".02." + q + ".bin", ios::binary | ios::app);       //arquivo compressao
  674.         comp_file_v3.open(path + timestampString + s + ".03." + q + ".bin", ios::binary | ios::app);        //arquivo compressao
  675.         comp_file_i1.open(path + timestampString + s + ".04." + q + ".bin", ios::binary | ios::app);        //arquivo compressao
  676.         comp_file_i2.open(path + timestampString + s + ".05." + q + ".bin", ios::binary | ios::app);        //arquivo compressao
  677.         comp_file_i3.open(path + timestampString + s + ".06." + q + ".bin", ios::binary | ios::app);        //arquivo compressao
  678.         comp_file_in.open(path + timestampString + s + ".07." + q + ".bin", ios::binary | ios::app);        //arquivo compressao
  679.         timestamp_file.open(path + timestampString + s + ".08." + q + ".bin", ios::app);                    //arquivo delta timestamp
  680.            
  681.         if(flag_save_waveform)
  682.         {          
  683.             wave_file_v1.open(pathDebug + timestampString + s + ".01_wave_v1.bin", ios::binary | ios::app);      //arquivo forma de onda   
  684.             wave_file_v2.open(pathDebug + timestampString + s + ".02_wave_v2.bin", ios::binary | ios::app);        //arquivo forma de onda 
  685.             wave_file_v3.open(pathDebug + timestampString + s + ".03_wave_v3.bin", ios::binary | ios::app);        //arquivo forma de onda 
  686.             wave_file_i1.open(pathDebug + timestampString + s + ".04_wave_i1.bin", ios::binary | ios::app);        //arquivo forma de onda 
  687.             wave_file_i2.open(pathDebug + timestampString + s + ".05_wave_i2.bin", ios::binary | ios::app);        //arquivo forma de onda 
  688.             wave_file_i3.open(pathDebug + timestampString + s + ".06_wave_i3.bin", ios::binary | ios::app);        //arquivo forma de onda 
  689.             wave_file_in.open(pathDebug + timestampString + s + ".07_wave_in.bin", ios::binary | ios::app);        //arquivo forma de onda             
  690.             timestamp_aux.open(pathDebug + timestampString + s + "_timestamp.txt", ios::binary | ios::app);      //arquivo auxiliar de timestamp completo  
  691.         }          
  692.     }
  693.    
  694.     long calc_delta = (CompressionData.deltaTime - 200000);
  695.     int delta = trunc(calc_delta / 100);
  696.     cout << "Delta: " << delta << endl;
  697.    
  698.     if (blockNumber > 1)
  699.     {
  700.         timestamp_file.write((const char *)(&delta), sizeof(int8_t));
  701.         timestamp_file.flush();
  702.        
  703.         //timestamp_aux.write((const char *)(&calc_delta), sizeof(long));
  704.         timestamp_aux << CompressionData.TimeStamp << "\n";
  705.         timestamp_aux.flush();
  706.     }      
  707.    
  708.     c = 0; 
  709.     while (c < 7) //percorrer todos os canais
  710.     {  
  711.         cout << "Canal: " << c << endl;
  712.        
  713.         //zerar nível dc da FFT
  714.         CompressionData.Channels[c].FFTReal[0] = 0;
  715.         CompressionData.Channels[c].FFTImaginary[0] = 0;
  716.            
  717.         selectFile();   //atribuir para o comp_atual em qual arquivo deve salvar
  718.        
  719.         //escrever arquivo da forma de onda, para debug
  720.         wave_file.write((const char *)(&CompressionData.Channels[c].Waveform[0]), WAVEFORM_LENGHT * sizeof(int16_t));
  721.         wave_file.flush(); 
  722.        
  723.         if(c < 3)
  724.         {
  725.             //calcular magnitude máxima da referência
  726.             maxMagnitude =  abs(Ref[c][0]);
  727.             for (int i = 0; i < VECTOR_SIZE; i++)
  728.             {
  729.                 magRef[c][i] = abs(Ref[c][i]);
  730.                 if (magRef[c][i] > maxMagnitude)
  731.                     maxMagnitude = magRef[c][i];
  732.             }
  733.            
  734.             //criar vetor New
  735.             create_full_vector(New[c], CompressionData.Channels[c].FFTReal, CompressionData.Channels[c].FFTImaginary, CompressionData.Channels[c].FFTIndex, CompressionData.Channels[c].FFTSize);
  736.        
  737.             //calcular valor de epsilon
  738.             float epsilon = maxMagnitude * epsilon_perc;
  739.        
  740.             //calcular magnitudes do vetor new
  741.             for(int i = 0 ; i < VECTOR_SIZE ; i++)
  742.             {
  743.                 magNew[c][i] = abs(New[c][i]);
  744.                 if (magNew[c][i] < epsilon) //se magnitude for menor que valor, zerar valores da raia
  745.                     {
  746.                         New[c][i].real(0);
  747.                         New[c][i].imag(0);
  748.                         magNew[c][i] = 0;
  749.                     }
  750.             }
  751.            
  752.             //realiza compressão e calcula quantas raias mudaram
  753.             num_of_bins_changed[c] = compress_diff(Ref[c], New[c], indexChanged[c]);
  754.            
  755.             cout << "Changed: " << num_of_bins_changed[c] << endl;
  756.        
  757.             /*****  IGUAL A REFERÊNCIA  *****/
  758.             if (num_of_bins_changed[c] == 0)
  759.             {
  760.                 cout << "Nao mudou" << endl;
  761.                
  762.                 if (blockNumber >= 3000) //está finalizando arquivo, escrever número do bloco e 0 no tamanho
  763.                 {
  764.                     //Escrever número do bloco no arquivo
  765.                     comp_atual.write((const char *)(&blockNumber), sizeof(blockNumber));
  766.                    
  767.                     uint16_t size = 0;
  768.                     //Escrever quantidade de raias
  769.                     comp_atual.write((const char *)(&size), sizeof(uint16_t));
  770.                        
  771.                 }
  772.                    
  773.             }      
  774.             /*****  MUDOU ALGUMAS RAIAS  *****/
  775.             else if(num_of_bins_changed[c] > 0)
  776.             {
  777.                 cout << "Mudou" << endl;
  778.        
  779.                 //Escrever número do bloco no arquivo
  780.                 comp_atual.write((const char *)(&blockNumber), sizeof(blockNumber));
  781.        
  782.                 //Escrever quantidade de raias
  783.                 comp_atual.write((const char *)(&num_of_bins_changed[c]), sizeof(uint16_t));
  784.        
  785.                 //Escrever Index   
  786.                 comp_atual.write((const char *)(&indexChanged[c]), num_of_bins_changed[c] * sizeof(uint16_t));
  787.        
  788.                 //Escrever Raias (real, imaginário)                   
  789.                 for(int i = 0 ; i < num_of_bins_changed[c] ; i++)
  790.                 {          
  791.                     int16_t value_real;
  792.                     value_real = round(Ref[c][indexChanged[c][i]].real() * 1.5);
  793.                
  794.                     int16_t value_im;
  795.                     value_im = round(Ref[c][indexChanged[c][i]].imag() * 1.5);
  796.                
  797.                     comp_atual.write((const char *)(&value_real), sizeof(int16_t));
  798.                     comp_atual.write((const char *)(&value_im), sizeof(int16_t));
  799.                 }
  800.             }
  801.             /*****  MUDOU MUITAS RAIAS, ENVIAR FORMA DE ONDA  *****/
  802.             else if(num_of_bins_changed[c] == -1)
  803.             {
  804.                 cout << "Forma de onda" << endl;
  805.        
  806.                 //Escrever número do bloco no arquivo
  807.                 comp_atual.write((const char *)(&blockNumber), sizeof(blockNumber));
  808.                 //salvar FFT completa
  809.                 for(int j = 0 ; j < VECTOR_SIZE ; j++)
  810.                 {
  811.                     Ref[c][j] = New[c][j];
  812.                 }              
  813.        
  814.                 //escrever quantos mudou
  815.                 uint16_t size = WAVEFORM_LENGHT;
  816.                 comp_atual.write((const char *)(&size), sizeof(uint16_t));
  817.                 //escrever forma de onda no arquivo
  818.                 comp_atual.write((const char *)(&CompressionData.Channels[c].Waveform[0]), WAVEFORM_LENGHT * sizeof(int16_t));
  819.             }
  820.    
  821.             //for (int i = 0; i < VECTOR_SIZE; i++)
  822.             //{
  823.             //  fft_file.write((const char *)(&CompressionData.Channels[c].FFTReal[i]), sizeof(float));
  824.             //  fft_file.write((const char *)(&CompressionData.Channels[c].FFTImaginary[i]), sizeof(float));
  825.             //}
  826.             comp_atual.flush();    
  827.         }
  828.    
  829.         int result = 0;
  830.        
  831.         if (c >= 3) //corrente
  832.         {
  833.             if (reference_current)
  834.             {                      
  835.                
  836.                 result = compress_waveform(RefWave[c-3], CompressionData.Channels[c].Waveform);
  837.                 //cout << "Resultado: " << result << endl;
  838.                 if (!result) //diferente, salvar forma de onda
  839.                 {
  840.                     cout << "Mudou" << endl;
  841.                     int16_t block;
  842.                     block = -blockNumber;
  843.        
  844.                     //Escrever número do bloco no arquivo
  845.                     comp_atual.write((const char *)(&block), sizeof(block));
  846.                     //Escrever forma de onda no arquivo
  847.                     comp_atual.write((const char *)(&CompressionData.Channels[c].Waveform[0]), WAVEFORM_LENGHT * sizeof(int16_t));
  848.                    
  849.                     //Copiar forma de onda para referência
  850.                     memcpy(RefWave[c-3], CompressionData.Channels[c].Waveform, WAVEFORM_LENGHT*(sizeof(int16_t)));      
  851.                 }
  852.                 else //nada mudou
  853.                 {
  854.                     cout << "Não mudou" << endl;
  855.                     if (blockNumber >= 3000) //está finalizando arquivo, escrever número do bloco e 0 no tamanho
  856.                     {
  857.                         int16_t block;
  858.                         block = -blockNumber;
  859.        
  860.                         //Escrever número do bloco no arquivo
  861.                         comp_atual.write((const char *)(&block), sizeof(block));
  862.                    
  863.                         uint16_t size = 0;
  864.                         //Escrever quantidade de raias
  865.                         comp_atual.write((const char *)(&size), sizeof(uint16_t));                     
  866.                     }
  867.                 }
  868.             }
  869.             else
  870.             {
  871.                 if(c==6)
  872.                     reference_current = true;
  873.                
  874.                 //Copiar forma de onda para referência
  875.                 memcpy(RefWave[c-3], CompressionData.Channels[c].Waveform, WAVEFORM_LENGHT*(sizeof(int16_t)));    
  876.                                
  877.                 int16_t block;
  878.                 block = -blockNumber;  
  879.                
  880.                 cout << "Bloco: " << block << endl;
  881.                 //Escrever número do bloco no arquivo
  882.                 comp_atual.write((const char *)(&block), sizeof(int16_t));
  883.                 //Escrever forma de onda no arquivo
  884.                 comp_atual.write((const char *)(&CompressionData.Channels[c].Waveform[0]), WAVEFORM_LENGHT * sizeof(int16_t));
  885.             }
  886.            
  887.         }
  888.        
  889.         comp_atual.flush();    
  890.         changeFile();
  891.        
  892.         c++;
  893.     }
  894.    
  895.     if (blockNumber == 1500 || blockNumber >= 3000) //terminou arquivo, fechar arquivo e reiniciar variáveis
  896.     {
  897.         int16_t block;
  898.         block = 0xAAAA;        
  899.         //Escrever número do bloco no arquivo
  900.         comp_file_v1.write((const char *)(&block), sizeof(block));
  901.         comp_file_v2.write((const char *)(&block), sizeof(block));
  902.         comp_file_v3.write((const char *)(&block), sizeof(block));
  903.         comp_file_i1.write((const char *)(&block), sizeof(block));     
  904.         comp_file_i2.write((const char *)(&block), sizeof(block));
  905.         comp_file_i3.write((const char *)(&block), sizeof(block));
  906.         comp_file_in.write((const char *)(&block), sizeof(block));
  907.        
  908.         blockNumber = 0;
  909.         //fechar arquivos
  910.         comp_file_v1.close();
  911.         comp_file_v2.close();
  912.         comp_file_v3.close();
  913.         comp_file_i1.close();
  914.         comp_file_i2.close();
  915.         comp_file_i3.close();
  916.         comp_file_in.close();
  917.         timestamp_file.close();
  918.        
  919.         wave_file_v1.close();
  920.         wave_file_v2.close();
  921.         wave_file_v3.close();
  922.         wave_file_i1.close();
  923.         wave_file_i2.close();
  924.         wave_file_i3.close();
  925.         wave_file_in.close();
  926.         timestamp_aux.close();
  927.            
  928.         create_file = true;
  929.        
  930.         cout << "Fim do arquivo" << endl;
  931.        
  932.         if (flag_finish)
  933.         {
  934.             aquisicao++;
  935.             // Criar objeto json
  936.             json j;
  937.             j["aquisicao"] = aquisicao;
  938.             j["segmento"] = segmento;  // criar chave "segmento" para contem unsigned int (uint32_t)
  939.             std::ofstream o("/home/ubuntu/compression/compression.json"); // escrever JSON formatado para arquivo
  940.             o << std::setw(4) << j << std::endl;
  941.             o.close();   // Fecha Arquivo
  942.             cout << "Arquivo gerado" << endl;
  943.            
  944.             exit(0);           
  945.         }          
  946.     }
  947.    
  948.     if (flag_shutdown)
  949.     {
  950.         flag_shutdown = false;
  951.         flag_finish = true;
  952.     }
  953.        
  954.    
  955.     return 1;
  956. }
  957.  
  958. void selectFile()
  959. {
  960.     switch (c)
  961.     {
  962.         case 0:
  963.             comp_atual = move(comp_file_v1);   
  964.             wave_file = move(wave_file_v1);
  965.         break;
  966.         case 1:
  967.             comp_atual = move(comp_file_v2);   
  968.             wave_file = move(wave_file_v2);
  969.             break;
  970.         case 2:
  971.             comp_atual = move(comp_file_v3);   
  972.             wave_file = move(wave_file_v3);
  973.             break;
  974.         case 3:
  975.             comp_atual = move(comp_file_i1);
  976.             wave_file = move(wave_file_i1);
  977.             break;
  978.         case 4:
  979.             comp_atual = move(comp_file_i2);
  980.             wave_file = move(wave_file_i2);
  981.             break;
  982.         case 5:
  983.             comp_atual = move(comp_file_i3);   
  984.             wave_file = move(wave_file_i3);
  985.             break;
  986.         case 6:
  987.             comp_atual = move(comp_file_in);
  988.             wave_file = move(wave_file_in);
  989.             break;     
  990.     }  
  991. }
  992.  
  993. void changeFile()
  994. {
  995.     switch (c)
  996.     {
  997.     case 0:
  998.         comp_file_v1 = move(comp_atual);
  999.         wave_file_v1 = move(wave_file);
  1000.         break;
  1001.     case 1:
  1002.         comp_file_v2 = move(comp_atual);   
  1003.         wave_file_v2 = move(wave_file);
  1004.         break;
  1005.     case 2:
  1006.         comp_file_v3 = move(comp_atual);   
  1007.         wave_file_v3 = move(wave_file);
  1008.         break;
  1009.     case 3:
  1010.         comp_file_i1 = move(comp_atual);   
  1011.         wave_file_i1 = move(wave_file);
  1012.         break;
  1013.     case 4:
  1014.         comp_file_i2 = move(comp_atual);   
  1015.         wave_file_i2 = move(wave_file);
  1016.         break;
  1017.     case 5:
  1018.         comp_file_i3 = move(comp_atual);   
  1019.         wave_file_i3 = move(wave_file);
  1020.         break;
  1021.     case 6:
  1022.         comp_file_in = move(comp_atual);   
  1023.         wave_file_in = move(wave_file);
  1024.         break;     
  1025.     }  
  1026. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top