recreate.c

Go to the documentation of this file.

/* ----------------------------------------------------------------------------- 
 * recreate.c
 * 
 * iPDC - Phasor Data Concentrator
 *
 * Copyright (C) 2011 Nitesh Pandit
 * Copyright (C) 2011 Kedar V. Khandeparkar
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * Authors: 
 *              Kedar V. Khandeparkar <kedar.khandeparkar@gmail.com>                    
 *              Nitesh Pandit <panditnitesh@gmail.com>                          
 *
 * ----------------------------------------------------------------------------- */


#include  <stdio.h>
#include  <string.h>
#include  <stdlib.h> 
#include  <pthread.h>
#include  "parser.h"
#include  "global.h" 
#include  "recreate.h"


/* ---------------------------------------------------------------------*/
/*                  Functions defined in recreate.c                     */
/* ---------------------------------------------------------------------*/

/*                 1.  recreate_cfg_objects()                           */
/*                 2.  void init_cfgparser()                            */

/* -------------------------------------------------------------------- */



/* ---------------------------------------------------------------------------- */
/* FUNCTION  recreate_cfg_objects():                                            */
/* It re-creates Configuration Objects from file cfg.bin if the ./server        */
/* program is stopped abruptly. It internally calls init_cfgparser()            */
/* ---------------------------------------------------------------------------- */

void recreate_cfg_objects(){ 

/* ---------------------------------------------------------------- */
/*        Initialize Global Mutex Variable from global.h            */
/* ---------------------------------------------------------------- */
        pthread_mutex_init(&mutex_file, NULL);
        pthread_mutex_init(&mutex_cfg, NULL);
        pthread_mutex_init(&mutex_MYSQL_CONN_ON_DATA, NULL);
        pthread_mutex_init(&mutex_MYSQL_CONN_ON_CFG, NULL);

        static const char filename[] = "cfg.bin";        

        FILE *file = fopen (filename,"rb");
        unsigned char *line,frame_len[2];
        unsigned int framesize;
        unsigned long fileLen;

        if (file != NULL) {

                        //Get file length
                        fseek(file, 0, SEEK_END);
                        fileLen = ftell(file);
                        fseek(file, 0, SEEK_SET);
                        printf("FILE LEN LEFT %ld\n",fileLen);
                        printf("Creating objects for entries in cfg.bin\n");

                        while (fileLen != 0) /* Till the EOF */{

                                fseek (file,2 ,SEEK_CUR);
                                fread(frame_len, sizeof(unsigned char),2, file);
                                fseek (file,-4 ,SEEK_CUR);
                                
                                framesize = to_intconvertor(frame_len);
                                line = malloc(framesize*sizeof(unsigned char));
                                memset(line,'\0',sizeof(line));
                                fread(line, sizeof(unsigned char),framesize,file);                              
                                init_cfgparser(line);
                                free(line);
                                fileLen -= framesize;
                        }
                        fclose (file);

        } else {
                        perror (filename); /* why didn't the file open? */
        }
} 


/* ---------------------------------------------------------------------------- */
/* FUNCTION  init_cfgparser():                                                  */
/* It is called by recreate_cfg_object() to read the file `cfg.bin`             */
/* and create cfg objects in the memory                                         */
/* ---------------------------------------------------------------------------- */
void init_cfgparser(unsigned char st[]){ 

          unsigned char *s;
          int cfglen = 0;
          int i,j,k,dgchannels;
          struct cfg_frame *cfg;
          struct channel_names *cn;
          unsigned long int l_phunit,l_anunit;

          unsigned char *sync,*frame_size,*idcode_h,*soc,*fracsec,*time_base,*num_pmu,*stn,*idcode_l,*format,*phnmr,*annmr,*dgnmr;
          unsigned char *fnom,*cfg_cnt,*data_rate,*buf;

          sync = malloc(3);
          frame_size = malloc(3);
          idcode_h= malloc(3);
          soc = malloc(5);
          fracsec = malloc(5);
          time_base = malloc(5);
          num_pmu = malloc(3);
          stn = malloc(17);
          idcode_l = malloc(3);
          format = malloc(5);
          phnmr = malloc(3);
          annmr = malloc(3);
          dgnmr = malloc(3);

          fnom = malloc(3);
          cfg_cnt = malloc(3);
          data_rate = malloc(3);
          buf = malloc(9);
        

          memset(sync,'\0',3);
          memset(frame_size,'\0',3);
          memset(idcode_h,'\0',3);
          memset(soc,'\0',3);
          memset(fracsec,'\0',5);
          memset(time_base,'\0',5);
          memset(num_pmu,'\0',3);
          memset(stn,'\0',17);
          memset(idcode_l,'\0',3);
          memset(format,'\0',3);
          memset(phnmr,'\0',3);
          memset(annmr,'\0',3);
          memset(dgnmr,'\0',3);
        
          memset(fnom,'\0',3);
          memset(cfg_cnt ,'\0',3);
          memset(data_rate,'\0',3);
          memset(buf,'\0',9);
        

/******************** PARSING BEGINGS *******************/

           pthread_mutex_lock(&mutex_file);
          
           cfg = malloc(sizeof(struct cfg_frame));
           if(!cfg) {
                printf("No enough memory for cfg\n");
           }

           printf("Inside INIT cfgparser()\n");
           s = st;

         //Copy sync word to file
          copy_cbyc (sync,s,2);
          sync[2] = '\0';
          s = s + 2;

        // Separate the FRAME SIZE
          copy_cbyc (frame_size,s,2);
          frame_size[2]='\0';
          cfg->framesize = to_intconvertor(frame_size);
          printf("FRAME SIZE %d\n",cfg->framesize);
          s = s + 2;
          cfglen += 2;

         //SEPARATE IDCODE
          copy_cbyc (idcode_h,s,2);
          idcode_h[2] = '\0';
          cfg->idcode = to_intconvertor(idcode_h);
          printf("ID Code %d\n",cfg->idcode);
          s = s + 2;
          cfglen += 2;
        
         //SEPARATE SOC 
          copy_cbyc (soc,s,4);
          soc[4] = '\0';
          sscanf((unsigned int *)soc,"%x", (unsigned int *)&cfg->soc);                  
          printf("SOC %ld\n",cfg->soc);
          s =s + 4;
          cfglen += 4;

         //SEPARATE FRACSEC     
          copy_cbyc (fracsec, s,4);
          fracsec[4] = '\0';
          cfg->fracsec = to_long_int_convertor(fracsec);         
          printf("FracSec %ld\n",cfg->fracsec);
          s = s + 4;
          cfglen += 4;
        
          //SEPARATE TIMEBASE
          copy_cbyc (time_base, s,4);
          time_base[4]='\0';
          cfg->time_base = to_long_int_convertor(time_base);                    
          printf("Time Base %ld\n",cfg->time_base);
          s = s + 4;
          cfglen += 4;

          //SEPARATE PMU NUM
          copy_cbyc (num_pmu, s,2);
          num_pmu[2] = '\0';    
          cfg->num_pmu = to_intconvertor(num_pmu);              
          printf("Number of PMU's %d\n",cfg->num_pmu);
          s = s + 2;
          cfglen += 2;

          // Allocate Memeory For Each PMU
          cfg->pmu = malloc(cfg->num_pmu* sizeof(struct for_each_pmu *));
          if(!cfg->pmu) {
              printf("Not enough memory pmu[][]\n");
              exit(1);
          }
        
          for (i = 0; i < cfg->num_pmu; i++) {
              cfg->pmu[i] = malloc(sizeof(struct for_each_pmu));
          }
        
          j = 0;
                
          while(j<cfg->num_pmu) {

                  //SEPARATE STATION NAME
                  memset(cfg->pmu[j]->stn,'\0',17);
                  copy_cbyc (cfg->pmu[j]->stn, s,16);
                  cfg->pmu[j]->stn[16] = '\0';

                  printf("STATION NAME %s\n",cfg->pmu[j]->stn);                         
                  s = s + 16;
                  cfglen += 16;

                  //SEPARATE IDCODE             
                  copy_cbyc (idcode_l, s,2);
                  idcode_l[2]='\0';
                  cfg->pmu[j]->idcode = to_intconvertor(idcode_l);
                  printf("ID Code %d\n",cfg->pmu[j]->idcode);
                  s = s + 2;
                  cfglen += 2;
        
                  //SEPARATE DATA FORMAT                
                  copy_cbyc ((unsigned char *) cfg->pmu[j]->data_format, s,2);
                  cfg->pmu[j]->data_format[2]='\0';
                  printf("PMU format %s\n",cfg->pmu[j]->data_format);
                  s = s + 2;
                  cfglen += 2;

                  char hex = cfg->pmu[j]->data_format[1];
                  hex <<= 4;
                        
                  // Extra field has been added to identify polar,rectangular,floating/fixed point      
                  cfg->pmu[j]->fmt = malloc(sizeof(struct format));
                  cfg->pmu[j]->fmt->freq = (hex & 0x80) >> 7;
                  cfg->pmu[j]->fmt->analog = (hex & 0x40) >> 6;
                  cfg->pmu[j]->fmt->phasor = (hex & 0x20) >> 5;
                  cfg->pmu[j]->fmt->polar = (hex & 0x10) >> 4;       
                     
                  //SEPARATE PHASORS    
                  copy_cbyc (phnmr, s,2);
                  phnmr[2]='\0';
                  cfg->pmu[j]->phnmr = to_intconvertor(phnmr);
                  printf("Phasors %d\n",cfg->pmu[j]->phnmr);
                  s = s + 2;
                  cfglen += 2;

                  //SEPARATE ANALOGS                    
                  copy_cbyc (annmr, s,2);
                  annmr[2]='\0';
                  cfg->pmu[j]->annmr = to_intconvertor(annmr);
                  printf("Analogs %d\n",cfg->pmu[j]->annmr);
                  s = s + 2;
                  cfglen += 2;

                  //SEPARATE DIGITALS                   
                  copy_cbyc (dgnmr, s,2);
                  dgnmr[2]='\0';
                  cfg->pmu[j]->dgnmr = to_intconvertor(dgnmr);
                  printf("Digitals %d\n",cfg->pmu[j]->dgnmr);
                  s = s + 2; 
                  cfglen += 2;

                  cn = malloc(sizeof(struct channel_names));
                  cn->first = NULL;

                 if(cfg->pmu[j]->phnmr != 0){
                           cn->phnames = malloc((cfg->pmu[j]->phnmr) * sizeof(char*));
                           if(!cn->phnames) {
                                   printf("Not enough memory cfg->pmu[j]->cn->phnames[][]\n");
                                   exit(1);
                           }
                
                        for (i = 0; i < cfg->pmu[j]->phnmr; i++) {

                                cn->phnames[i] = malloc(17*sizeof(char));
                                memset(cn->phnames[i],'\0',17);

                        }

                        cfg->pmu[j]->phunit = malloc(cfg->pmu[j]->phnmr*sizeof(float*));
                        if(!cfg->pmu[j]->phunit) {
                                printf("Not enough memory cfg.pmu[j]->phunit[][]\n");
                                exit(1);
                        }
        
                        for (i = 0; i < cfg->pmu[j]->phnmr; i++) {
                                cfg->pmu[j]->phunit[i] = malloc(sizeof(float));
                        }

                
                        i = 0;//Index for PHNAMES
                        while(i<cfg->pmu[j]->phnmr){

                                copy_cbyc (cn->phnames[i], s,16);
                                cn->phnames[i][16] = '\0';
                                printf("Phnames %s\n",cn->phnames[i]);
                                s = s + 16;
                                cfglen += 16;
                                i++;
                        }       
                 }              
                                        
                //SEPARATE ANALOG NAMES
                 if(cfg->pmu[j]->annmr != 0){
                          cn->angnames = malloc((cfg->pmu[j]->annmr)*sizeof(char*));
                          if(!cn->angnames) {

                                printf("Not enough memory cfg->pmu[j]->cn->phnames[][]\n");
                                exit(1);
                          }
                        
                          for (i = 0; i < cfg->pmu[j]->annmr; i++) {

                                cn->angnames[i] = malloc(17*sizeof(char));
                                memset(cn->angnames[i],'\0',17);
                          }
                        
                          cfg->pmu[j]->anunit = malloc(cfg->pmu[j]->annmr*sizeof(float*));
                          if(!cfg->pmu[j]->anunit) {
                                printf("Not enough memory cfg.pmu[j]->anunit[][]\n");
                                exit(1);
                          }

                          for (i = 0; i < cfg->pmu[j]->annmr; i++) {
                                cfg->pmu[j]->anunit[i] = malloc(sizeof(float));
                          }
                         
                          i = 0;//Index for ANGNAMES

                          while(i<cfg->pmu[j]->annmr){
                                copy_cbyc (cn->angnames[i], s,16);
                                cn->angnames[i][16]='\0';
                                printf("ANGNAMES %s\n",cn->angnames[i]);
                                s = s + 16; 
                                cfglen += 16;
                                i++;
                          }
                 }
                        

                 if(cfg->pmu[j]->dgnmr != 0){
                
                        cfg->pmu[j]->dgunit = malloc(cfg->pmu[j]->dgnmr*sizeof(char*));
                        if(!cfg->pmu[j]->dgunit) {

                                printf("Not enough memory cfg->pmu[j]->dgunit[][]\n");
                                exit(1);
                        }
                
                        for (i = 0; i < cfg->pmu[j]->dgnmr; i++) {

                                cfg->pmu[j]->dgunit[i] = malloc(5);
                        }
                 }
                 struct dgnames *q;
                 i = 0; //Index for number of dgwords
                 while(i < cfg->pmu[j]->dgnmr) {

                        struct dgnames *temp1 = malloc(sizeof(struct dgnames));
                        temp1->dgn = malloc(16*sizeof(char *)); 
                        if(!temp1->dgn) {

                                printf("Not enough memory temp1->dgn\n");
                                exit(1);
                        }

                        for (i = 0; i < 16; i++) {

                                temp1->dgn[i] = malloc(17*sizeof(char));

                        }
                        
                        temp1->dg_next = NULL;

                        for(dgchannels = 0;dgchannels < 16;dgchannels++){

                                   memset(temp1->dgn[dgchannels],'\0',16);
                                   copy_cbyc (temp1->dgn[dgchannels], s,16);
                                   temp1->dgn[dgchannels][16] = '\0';
                                   s += 16;
                                   cfglen += 16;
                                   k = 0;  
                                   printf("%s\n",temp1->dgn[dgchannels]);
                         }

                         if(cn->first == NULL){
                                cn->first = q = temp1;

                         } else {

                                while(q->dg_next!=NULL){
                                        q = q->dg_next;
                                }
                                q->dg_next = temp1;                            
                         }  
                 
                        i++;  
                } //DGWORD WHILE ENDS

                cfg->pmu[j]->cnext = cn;//Assign to pointers

                if(cfg->pmu[j]->phnmr != 0){
                
                        i = 0;
                        while(i < cfg->pmu[j]->phnmr){ //Separate the Phasor conversion factors

                                  memset(buf,'\0',9);
                                  copy_cbyc (buf, s,4);
                                  buf[4] = '\0';
                                  l_phunit = to_long_int_convertor(buf);
                                  *cfg->pmu[j]->phunit[i] = l_phunit * 0.00001;
                                  printf("Phasor Fact %d = %f\n",i,*cfg->pmu[j]->phunit[i]);
                                  s = s + 4;
                                  cfglen += 4;
                                  i++;
                        }
                  }//if for PHASOR Factors ends
        
                //ANALOG FACTORS
                  if(cfg->pmu[j]->annmr != 0){

                        i=0;
                        while(i<cfg->pmu[j]->annmr){ //Separate the Phasor conversion factors

                                  memset(buf,'\0',9);
                                  copy_cbyc (buf, s,4);
                                  buf[4] = '\0';
                                  l_anunit = to_long_int_convertor(buf);
                                  *cfg->pmu[j]->anunit[i] = l_anunit*0,00001;
                                  printf("Analog Fact %d = %f\n",i,*cfg->pmu[j]->anunit[i]);
                                  s = s + 4;
                                  cfglen += 4;
                                  i++;
                        }
        
                  } // if for ANALOG FActtors ends
                
                  if(cfg->pmu[j]->dgnmr != 0){
                
                        i = 0;
                        while(i < cfg->pmu[j]->dgnmr ){ //Separate the Phasor conversion factors

                                  copy_cbyc(cfg->pmu[j]->dgunit[i],s,4);
                                  cfg->pmu[j]->dgunit[i][4] = '\0';
                                  printf("DGWORD %s\n",cfg->pmu[j]->dgunit[i]); 
                                  s += 4;
                                  cfglen += 4;
                                  i++;
                        }
                  } //if for Digital Words FActtors ends
                                        
                  copy_cbyc (fnom, s,2);
                  fnom[2]='\0';
                  cfg->pmu[j]->fnom = to_intconvertor(fnom);
                  printf("FREQUENCY %d\n",cfg->pmu[j]->fnom);
                  s = s + 2;
                  cfglen += 2;
                
                  copy_cbyc (cfg_cnt, s,2);
                  cfg_cnt[2] = '\0';
                  cfg->pmu[j]->cfg_cnt = to_intconvertor(cfg_cnt);
                  printf("CFG CHANGE COUNT %d\n",cfg->pmu[j]->cfg_cnt);
                  s = s + 2;
                  cfglen += 2;
                  j++; 
          }//While for PMU number ends
                
                
          copy_cbyc (data_rate, s,2);
          data_rate[2] = '\0';
          cfg->data_rate = to_intconvertor(data_rate);
          printf("Data Rate %d\n",cfg->data_rate);
          s += 2;
          cfglen += 2;
          cfg->cfgnext = NULL;
     
// Adjust the configuration object pointers
// Lock the mutex_cfg    
        pthread_mutex_lock(&mutex_cfg);

        if (cfgfirst == NULL)  { // Main if

                cfgfirst = cfg; 

        } else {

                struct cfg_frame *temp_cfg = cfgfirst;

                //Check if the configuration frame already exists
                while(temp_cfg->cfgnext != NULL){

                        temp_cfg = temp_cfg->cfgnext;
                        
                }// While ends
                temp_cfg->cfgnext = cfg;
          
        } //Main if

        pthread_mutex_unlock(&mutex_cfg);
        pthread_mutex_unlock(&mutex_file);

        free(sync);
        free(frame_size);
        free(idcode_h);
        free(soc);
        free(fracsec);
        free(time_base);
        free(num_pmu);
        free(stn);
        free(idcode_l);
        free(format);
        free(phnmr);
        free(annmr);
        free(dgnmr);
        free(fnom);
        free(cfg_cnt);
        free(data_rate);
        free(buf);


} 

---