From b8feaae7d51b3fd621b6ec05cf1c2f9b53d97f11 Mon Sep 17 00:00:00 2001 From: karthikmurakonda Date: Fri, 28 Oct 2022 19:19:35 +0530 Subject: [PATCH 1/6] bugfix mutexs --- iPDC/src/map_vis.c | 1 + 1 file changed, 1 insertion(+) diff --git a/iPDC/src/map_vis.c b/iPDC/src/map_vis.c index 554729d..7db20f5 100644 --- a/iPDC/src/map_vis.c +++ b/iPDC/src/map_vis.c @@ -28,6 +28,7 @@ gboolean update_images(gpointer* pars){ struct Lower_Layer_Details *LLptr; if (df == NULL){ + pthread_mutex_unlock(&mutex_on_TSB); return TRUE; } //int freq = to_intconvertor(df->dpmu[0]->freq); From b10a48516cb14c4d98ed19d6b81f40bc3e1123b4 Mon Sep 17 00:00:00 2001 From: pavanvpatil Date: Fri, 28 Oct 2022 19:32:32 +0530 Subject: [PATCH 2/6] AlGO DONE FOR GAUSSIAN --- iPDC/inc/Attack_detect.h | 4 +- iPDC/src/Attack_detect.c | 165 ++++++++++++++++++++++++++++++++++----- 2 files changed, 148 insertions(+), 21 deletions(-) diff --git a/iPDC/inc/Attack_detect.h b/iPDC/inc/Attack_detect.h index 060f2f2..79d2563 100644 --- a/iPDC/inc/Attack_detect.h +++ b/iPDC/inc/Attack_detect.h @@ -1,8 +1,8 @@ /* pavan changes */ -#include #include /* variables declared of attack_detect function */ /* function declared */ -gboolean attack_detect(struct data_frame *df); +gboolean attack_detect_freq(struct data_frame *df); +gboolean attack_detect_vol(struct data_frame *df) /* pavan changes */ \ No newline at end of file diff --git a/iPDC/src/Attack_detect.c b/iPDC/src/Attack_detect.c index 3fd8fbc..fec5cf2 100644 --- a/iPDC/src/Attack_detect.c +++ b/iPDC/src/Attack_detect.c @@ -6,34 +6,161 @@ #include #include "parser.h" -long double AVERAGE_OF_FREQUENCY = 50; -unsigned long long int COUNT = 500; - -gboolean attack_detect(struct data_frame *df) +struct freqlist { - float CURR_FREQ = 50 + to_intconvertor(df->dpmu[0]->freq) * 1e-3; - printf("Current freq: %f\n", CURR_FREQ); - float DETECT_PERCENT = (fabs(AVERAGE_OF_FREQUENCY - CURR_FREQ) / (AVERAGE_OF_FREQUENCY * 1.0f)) * 100; + int idcode; + long double AVERAGE_OF_FREQUENCY; + unsigned long long int COUNT; + struct freqlist* next; +}; - /* detecting based on thershold frequency can vary only around 0.2 hz*/ - if (DETECT_PERCENT > 0.9) +struct vollist +{ + int idcode; + long double AVERAGE_OF_VOLTAGE; + unsigned long long int COUNT; +}; + + +struct freqlist *head = NULL; +struct vollist *headvol = NULL + +gboolean attack_detect_freq(struct data_frame *df) +{ + if (head == NULL) { - printf("\033[0;31m"); - printf("ATTACK DETECTED!"); - printf("\033[0m"); - return FALSE; + head = (struct freqlist *)malloc(sizeof(struct freqlist)); + head->AVERAGE_OF_FREQUENCY = 50; + head->COUNT = 500; + return TRUE; } else { - printf("\033[0;32m"); - printf("NO PROBLEM :)\n"); - printf("\033[0m"); + struct freqlist *temp = head; + struct freqlist *previous = NULL; + while (temp != NULL) + { + if (to_intconvertor(df->idcode) == temp->idcode) + { + float CURR_FREQ; + if (df->dpmu[0]->fmt->freq == '0'){ + CURR_FREQ = 50 + to_intconvertor(df->dpmu[0]->freq) * 1e-3; + } + else{ + CURR_FREQ = decode_ieee_single(df->dpmu[0]->freq); + } + printf("Current freq: %f\n", CURR_FREQ); + float DETECT_PERCENT = (fabs(temp->AVERAGE_OF_FREQUENCY - CURR_FREQ) / (temp->AVERAGE_OF_FREQUENCY * 1.0f)) * 100; - /* updating mean of frequency */ - AVERAGE_OF_FREQUENCY = ((AVERAGE_OF_FREQUENCY * COUNT) + CURR_FREQ) / ++COUNT; - printf("avg freq: %Lf\n", AVERAGE_OF_FREQUENCY); + /* detecting based on thershold frequency can vary only around 0.2 hz*/ + if (DETECT_PERCENT > 0.9) + { + printf("\033[0;31m"); + printf("ATTACK DETECTED!"); + printf("\033[0m"); + return FALSE; + } + else + { + printf("\033[0;32m"); + printf("NO PROBLEM :)\n"); + printf("\033[0m"); + + /* updating mean of frequency */ + temp->AVERAGE_OF_FREQUENCY = ((temp->AVERAGE_OF_FREQUENCY * temp->COUNT) + CURR_FREQ) / ++temp->COUNT; + printf("avg freq: %Lf\n", temp->AVERAGE_OF_FREQUENCY); + return TRUE; + } + } + previous=temp; + temp=temp->next; + } + if(temp==NULL) + { + struct freqlist* bring = (struct freqlist *)malloc(sizeof(struct freqlist)); + bring = (struct freqlist *)malloc(sizeof(struct freqlist)); + bring->AVERAGE_OF_FREQUENCY = 50; + bring->COUNT = 500; + previous->next=bring; + return TRUE; + } + } +} + +gboolean attack_detect_vol(struct data_frame *df) +{ + float CURR_vol; + if (df->dpmu[0]->fmt->phasor == '0') + { + unsigned char s1[2]; + unsigned char s2[2]; + strncpy(s1, df->dpmu[0]->phasors[0], 2); + strncpy(s2, df->dpmu[0]->phasors[0] + 2, 2); + long double v1 = to_intconvertor(s1); + long double v2 = to_intconvertor(s2); + CURR_vol = sqrt((v1 * v1) + (v2 * v2)); + } + else + { + unsigned char s1[2]; + unsigned char s2[2]; + strncpy(s1, df->dpmu[0]->phasors[0], 4); + strncpy(s2, df->dpmu[0]->phasors[0] + 2, 4); + long double v1 = decode_ieee_single(s1); + long double v2 = decode_ieee_single(s2); + CURR_vol = sqrt((v1 * v1) + (v2 * v2)); + } + if (head == NULL) + { + head = (struct vollist *)malloc(sizeof(struct vollist)); + head->AVERAGE_OF_VOLTAGE = CURR_vol; + head->COUNT = 500; return TRUE; } + else + { + struct vollist *temp = head; + struct vollist *previous = NULL; + while (temp != NULL) + { + if (to_intconvertor(df->idcode) == temp->idcode) + { + printf("Current vol: %f\n", CURR_vol); + float DETECT_PERCENT = (fabs(temp->AVERAGE_OF_VOLTAGE - CURR_vol) / (temp->AVERAGE_OF_VOLTAGE * 1.0f)) * 100; + + /* detecting based on thershold VOLTAGE can vary only around 0.2 hz*/ + if (DETECT_PERCENT > 5) + { + printf("\033[0;31m"); + printf("ATTACK DETECTED!"); + printf("\033[0m"); + return FALSE; + } + else + { + printf("\033[0;32m"); + printf("NO PROBLEM :)\n"); + printf("\033[0m"); + + /* updating mean of VOLTAGE */ + temp->AVERAGE_OF_VOLTAGE = ((temp->AVERAGE_OF_VOLTAGE * temp->COUNT) + CURR_vol) / ++temp->COUNT; + printf("avg vol: %Lf\n", temp->AVERAGE_OF_VOLTAGE); + return TRUE; + } + } + previous = temp; + temp = temp->next; + } + if (temp == NULL) + { + struct vollist *bring = (struct vollist *)malloc(sizeof(struct vollist)); + bring = (struct vollist *)malloc(sizeof(struct vollist)); + bring->AVERAGE_OF_VOLTAGE = CURR_vol; + bring->COUNT = 500; + previous->next = bring; + return TRUE; + } + } } /* pavan changes */ \ No newline at end of file From f438835200b7701002f33f9767d877b35953a0fe Mon Sep 17 00:00:00 2001 From: pavanvpatil Date: Fri, 28 Oct 2022 22:12:22 +0530 Subject: [PATCH 3/6] need to apply kmeans 2 --- iPDC/inc/Attack_detect.h | 3 ++- iPDC/src/Attack_detect.c | 8 ++++++++ iPDC/src/Dynamic_time_warping.c | 5 +++++ 3 files changed, 15 insertions(+), 1 deletion(-) diff --git a/iPDC/inc/Attack_detect.h b/iPDC/inc/Attack_detect.h index 79d2563..9d42732 100644 --- a/iPDC/inc/Attack_detect.h +++ b/iPDC/inc/Attack_detect.h @@ -4,5 +4,6 @@ /* function declared */ gboolean attack_detect_freq(struct data_frame *df); -gboolean attack_detect_vol(struct data_frame *df) +gboolean attack_detect_vol(struct data_frame *df); +gboolean attack_detect_freq_vol(struct data_frame *df); /* pavan changes */ \ No newline at end of file diff --git a/iPDC/src/Attack_detect.c b/iPDC/src/Attack_detect.c index fec5cf2..40e5c07 100644 --- a/iPDC/src/Attack_detect.c +++ b/iPDC/src/Attack_detect.c @@ -5,6 +5,7 @@ #include #include #include "parser.h" +#include "Attack_detect.h" struct freqlist { @@ -163,4 +164,11 @@ gboolean attack_detect_vol(struct data_frame *df) } } +gboolean attack_detect_freq_vol(struct data_frame *df) +{ + return attack_detect_freq(df) && attack_detect_vol(df); +} + + + /* pavan changes */ \ No newline at end of file diff --git a/iPDC/src/Dynamic_time_warping.c b/iPDC/src/Dynamic_time_warping.c index 2147791..700b81a 100644 --- a/iPDC/src/Dynamic_time_warping.c +++ b/iPDC/src/Dynamic_time_warping.c @@ -295,4 +295,9 @@ int DTWvolDistance(struct data_frame *df) } return temp->result; } +} + +int DTWfreqvolDistance(struct data_frame *df) +{ + return DTWfreqDistance(df) && DTWfreqvolDistance(df); } \ No newline at end of file From 394c45555cb2faf5af40d71c4ad2ee0daed9b362 Mon Sep 17 00:00:00 2001 From: karthikmurakonda Date: Sat, 29 Oct 2022 13:07:00 +0530 Subject: [PATCH 4/6] added new datastructure to store pmu details --- iPDC/assets/utility_tools.ui | 36 +++- iPDC/assets/utility_tools.ui~ | 303 +++++++++++++++++++++++++++++--- iPDC/inc/map_vis.h | 8 +- iPDC/src/Attack_detect.c | 13 +- iPDC/src/Dynamic_time_warping.c | 40 ++--- iPDC/src/map_vis.c | 49 ++++-- iPDC/src/new_pmu_or_pdc.c | 1 + iPDC/src/utility_tools.c | 139 ++++++++++++++- 8 files changed, 512 insertions(+), 77 deletions(-) diff --git a/iPDC/assets/utility_tools.ui b/iPDC/assets/utility_tools.ui index 153d59a..2989aee 100644 --- a/iPDC/assets/utility_tools.ui +++ b/iPDC/assets/utility_tools.ui @@ -3,7 +3,7 @@ - 800 + 900 700 False @@ -409,7 +409,39 @@ - + + + True + False + + + True + True + True + rgb(119,118,123) + + + 0 + 0 + + + + + True + False + No data + + + 1 + 0 + + + + + False + True + 3 + diff --git a/iPDC/assets/utility_tools.ui~ b/iPDC/assets/utility_tools.ui~ index 3dba50e..94ca09a 100644 --- a/iPDC/assets/utility_tools.ui~ +++ b/iPDC/assets/utility_tools.ui~ @@ -4,7 +4,7 @@ 800 - 600 + 700 False @@ -169,7 +169,7 @@ - + 100 80 @@ -179,7 +179,7 @@ 10 6 - + 80 True @@ -187,7 +187,7 @@ 35 - Voltage + Voltage Magnitude True True True @@ -218,7 +218,7 @@ 0 - 2 + 3 @@ -227,13 +227,14 @@ False 0 - kmeans - simple + Gaussian + kmeans + DTW 0 - 3 + 5 @@ -243,15 +244,52 @@ 0 frequency only - frequency,voltage - voltage + voltage only + frequency,voltage + + 0 + 7 + + + + + dfreq + True + True + True + + + 0 + 2 + + + + + True + False + Algorithm + 0 4 + + + True + False + Dimmensions + + + 0 + 6 + + + + + 0 @@ -271,22 +309,243 @@ - + + 150 + True + False + + + 1 + 1 + - + + True + False + vertical + + + True + False + Legend + True + + + False + True + 0 + + + + + + True + False + + + True + True + True + red + rgb(238,29,0) + + + 0 + 0 + + + + + True + False + Attack/Event + + + 1 + 0 + + + + + False + True + 1 + + + + + + True + False + + + True + True + True + rgb(0,255,0) + + + 0 + 0 + + + + + True + False + Normal + + + 1 + 0 + + + + + False + True + 2 + + + + + + True + False + + + True + True + True + rgb(119,118,123) + + + 0 + 0 + + + + + True + False + No data + + + 1 + 0 + + + + + False + True + 3 + + + + + + + + 2 + 0 + - - - - - - - - - - + + True + True + in + + + True + False + + + True + False + vertical + + + True + False + Graph Legend + + + False + True + 0 + + + + + + True + False + + + True + True + True + rgb(255,120,0) + + + 0 + 0 + + + + + True + False + Pmu + + + 1 + 0 + + + + + False + True + 1 + + + + + True + True + True + + + False + True + 2 + + + + + True + True + True + + + False + True + 3 + + + + + + + + + 2 + 1 + diff --git a/iPDC/inc/map_vis.h b/iPDC/inc/map_vis.h index 0ae4ba2..37ac914 100644 --- a/iPDC/inc/map_vis.h +++ b/iPDC/inc/map_vis.h @@ -1,5 +1,7 @@ #include #include +#include "livechart.h" + typedef struct{ OsmGpsMap *util_map; GdkPixbuf *g_red_image; @@ -12,11 +14,13 @@ struct vis_data{ int id; float lat; float lon; - GdkPixbuf *last_image; + GdkColor color; + OsmGpsMapImage *last_image; // TODO: GTimeVal last_update_time; + LiveChartSerie *serie; struct vis_data *next; }; -struct vis_data *head; +struct vis_data *vis_data_head; gboolean update_images(gpointer* pars); \ No newline at end of file diff --git a/iPDC/src/Attack_detect.c b/iPDC/src/Attack_detect.c index 40e5c07..51c6699 100644 --- a/iPDC/src/Attack_detect.c +++ b/iPDC/src/Attack_detect.c @@ -20,11 +20,12 @@ struct vollist int idcode; long double AVERAGE_OF_VOLTAGE; unsigned long long int COUNT; + struct vollist* next; }; struct freqlist *head = NULL; -struct vollist *headvol = NULL +struct vollist *headvol = NULL; gboolean attack_detect_freq(struct data_frame *df) { @@ -111,16 +112,16 @@ gboolean attack_detect_vol(struct data_frame *df) long double v2 = decode_ieee_single(s2); CURR_vol = sqrt((v1 * v1) + (v2 * v2)); } - if (head == NULL) + if (headvol == NULL) { - head = (struct vollist *)malloc(sizeof(struct vollist)); - head->AVERAGE_OF_VOLTAGE = CURR_vol; - head->COUNT = 500; + headvol = (struct vollist *)malloc(sizeof(struct vollist)); + headvol->AVERAGE_OF_VOLTAGE = CURR_vol; + headvol->COUNT = 500; return TRUE; } else { - struct vollist *temp = head; + struct vollist *temp = headvol; struct vollist *previous = NULL; while (temp != NULL) { diff --git a/iPDC/src/Dynamic_time_warping.c b/iPDC/src/Dynamic_time_warping.c index 700b81a..8678814 100644 --- a/iPDC/src/Dynamic_time_warping.c +++ b/iPDC/src/Dynamic_time_warping.c @@ -30,25 +30,25 @@ struct DTWvollist }; -struct DTWfreqlist *head = NULL; -struct DTWvollist *headvol = NULL; +struct DTWfreqlist *dtwhead = NULL; +struct DTWvollist *dtwheadvol = NULL; int DTWfreqDistance(struct data_frame *df) { - if (head == NULL) + if (dtwhead == NULL) { - head = (struct DTWfreqlist *)malloc(sizeof(struct DTWfreqlist)); - head->count_track1 = 0; - head->count_track2 = 0; - head->flag = 0; - head->idcode = to_intconvertor(df->idcode); - head->next = NULL; - head->result=1; + dtwhead = (struct DTWfreqlist *)malloc(sizeof(struct DTWfreqlist)); + dtwhead->count_track1 = 0; + dtwhead->count_track2 = 0; + dtwhead->flag = 0; + dtwhead->idcode = to_intconvertor(df->idcode); + dtwhead->next = NULL; + dtwhead->result=1; return 1; } else { - struct DTWfreqlist *temp = head; + struct DTWfreqlist *temp = dtwhead; struct DTWfreqlist *previous; while (temp != NULL) { @@ -161,20 +161,20 @@ int DTWfreqDistance(struct data_frame *df) int DTWvolDistance(struct data_frame *df) { - if (headvol == NULL) + if (dtwheadvol == NULL) { - headvol = (struct DTWvollist *)malloc(sizeof(struct DTWvollist)); - headvol->count_track1 = 0; - headvol->count_track2 = 0; - headvol->flag = 0; - headvol->idcode = to_intconvertor(df->idcode); - headvol->next = NULL; - headvol->result=1; + dtwheadvol = (struct DTWvollist *)malloc(sizeof(struct DTWvollist)); + dtwheadvol->count_track1 = 0; + dtwheadvol->count_track2 = 0; + dtwheadvol->flag = 0; + dtwheadvol->idcode = to_intconvertor(df->idcode); + dtwheadvol->next = NULL; + dtwheadvol->result=1; return 1; } else { - struct DTWvollist *temp = headvol; + struct DTWvollist *temp = dtwheadvol; struct DTWvollist *previous; while (temp != NULL) { diff --git a/iPDC/src/map_vis.c b/iPDC/src/map_vis.c index 7db20f5..88dff2e 100644 --- a/iPDC/src/map_vis.c +++ b/iPDC/src/map_vis.c @@ -26,6 +26,7 @@ gboolean update_images(gpointer* pars){ pthread_mutex_lock(&mutex_on_TSB); struct data_frame *df = TSB[MAXTSB-1].first_data_frame; struct Lower_Layer_Details *LLptr; + struct vis_data *vis_ptr; if (df == NULL){ pthread_mutex_unlock(&mutex_on_TSB); @@ -45,17 +46,17 @@ gboolean update_images(gpointer* pars){ float lat; float lon; loops++; - // printf("loops: %d\n", loops); + printf("loops: %d\n", loops); id = to_intconvertor(df->idcode); - // printf("id = %d\n",id); + printf("id = %d\n",id); pthread_mutex_lock(&mutex_cfg); temp_cfg = cfgfirst; // Check for the IDCODE in Configuration Frame while(temp_cfg != NULL){ if(id == to_intconvertor(temp_cfg->idcode)){ cfg_match = 1; - // printf("Matched - id : %d\n",id); + printf("Matched - id : %d\n",id); freq_fmt = temp_cfg->pmu[0]->fmt->freq; anal_fmt = temp_cfg->pmu[0]->fmt->analog; phas_fmt = temp_cfg->pmu[0]->fmt->phasor; @@ -70,7 +71,7 @@ gboolean update_images(gpointer* pars){ // get data from df. if(freq_fmt == '1'){ freq = decode_ieee_single(df->dpmu[i]->freq); - // printf("freq = %f\n",freq); + printf("freq = %f\n",freq); }else{ freq = to_intconvertor(df->dpmu[i]->freq)*1e-6+50; } @@ -81,28 +82,42 @@ gboolean update_images(gpointer* pars){ strncpy(last2bytes, df->dpmu[i]->phasors[0]+2, 2); vol_magnitude = to_intconvertor(first2bytes); float imaginary = to_intconvertor(last2bytes); - // printf("vol = %f imag = %f\n",vol_magnitude, imaginary); + printf("vol = %f imag = %f\n",vol_magnitude, imaginary); live_chart_serie_add(serie, freq); // check lower layer details to get longitude and lattitude. - pthread_mutex_lock(&mutex_Lower_Layer_Details); - LLptr = LLfirst; + // pthread_mutex_lock(&mutex_Lower_Layer_Details); + // LLptr = LLfirst; + // match = 0; + // while(LLptr != NULL){ + // printf("pmuid = %d\n",LLptr->pmuid); + // if(LLptr->pmuid == id){ + // match = 1; + // lat = LLptr->latitude; + // lon = LLptr->longitude; + // printf("lat = %f; lon = %f\n",lat,lon); + // break; + // } + // LLptr = LLptr->next; + // } + // pthread_mutex_unlock(&mutex_Lower_Layer_Details); + + vis_ptr = vis_data_head; match = 0; - while(LLptr != NULL){ - // printf("pmuid = %d\n",LLptr->pmuid); - if(LLptr->pmuid == id){ + while(vis_ptr != NULL){ + printf("vis_ptr->id = %d\n",vis_ptr->id); + if(vis_ptr->id == id){ match = 1; - float lat = LLptr->latitude; - float lon = LLptr->longitude; + printf("Matched - id : %d\n",id); break; } - LLptr = LLptr->next; + vis_ptr = vis_ptr->next; } - pthread_mutex_unlock(&mutex_Lower_Layer_Details); - // if(match == 1 && cfg_match == 1){ - // printf("lat = %f, lon = %f, freq = %f\n",lat,lon,freq); + + if(match == 1 && cfg_match == 1){ + printf("lat = %f, lon = %f, freq = %f\n",lat,lon,freq); if(parameters->g_last_image != 0){ osm_gps_map_image_remove(parameters->util_map, parameters->g_last_image); } @@ -111,7 +126,7 @@ gboolean update_images(gpointer* pars){ }else{ parameters->g_last_image = osm_gps_map_image_add(parameters->util_map,lat, lon, parameters->g_red_image); } - // } + } df = df->dnext; // i++; k++; diff --git a/iPDC/src/new_pmu_or_pdc.c b/iPDC/src/new_pmu_or_pdc.c index fff224c..a6326d6 100755 --- a/iPDC/src/new_pmu_or_pdc.c +++ b/iPDC/src/new_pmu_or_pdc.c @@ -163,6 +163,7 @@ int add_PMU(char pmuid[], char ip[], char port[], char protocol[], char latitude temp_pmu->request_cfg_frame = 0; temp_pmu->latitude = atof(latitude); temp_pmu->longitude = atof(longitude); + printf(" lat = %f long = %f\n",temp_pmu->latitude,temp_pmu->longitude); temp_pmu->next = NULL; temp_pmu->prev = NULL; diff --git a/iPDC/src/utility_tools.c b/iPDC/src/utility_tools.c index 25a4b21..36db571 100644 --- a/iPDC/src/utility_tools.c +++ b/iPDC/src/utility_tools.c @@ -5,6 +5,7 @@ #include "map_vis.h" #include "utility_tools.h" #include "livechart.h" +#include "connections.h" #define UI_fILE "./assets/utility_tools.ui" #define RED_IMAGE "./assets/red.png" @@ -19,6 +20,106 @@ // } // on closing the window kill the g_timeout_add + +GdkRGBA getIndexColor(int index){ + GdkRGBA color; + // get the color from the index mathematically + switch(index){ + case 0: + color.red = 1.0; + color.green = 0.0; + color.blue = 0.0; + color.alpha = 1.0; + break; + case 1: + color.red = 0.0; + color.green = 1.0; + color.blue = 0.0; + color.alpha = 1.0; + break; + case 2: + color.red = 0.0; + color.green = 0.0; + color.blue = 1.0; + color.alpha = 1.0; + break; + case 3: + color.red = 1.0; + color.green = 1.0; + color.blue = 0.0; + color.alpha = 1.0; + break; + case 4: + color.red = 1.0; + color.green = 0.0; + color.blue = 1.0; + color.alpha = 1.0; + break; + case 5: + color.red = 0.0; + color.green = 1.0; + color.blue = 1.0; + color.alpha = 1.0; + break; + case 6: + color.red = 1.0; + color.green = 0.5; + color.blue = 0.0; + color.alpha = 1.0; + break; + case 7: + color.red = 0.0; + color.green = 0.5; + color.blue = 1.0; + color.alpha = 1.0; + break; + case 8: + color.red = 0.5; + color.green = 1.0; + color.blue = 0.0; + color.alpha = 1.0; + break; + case 9: + color.red = 0.5; + color.green = 0.0; + color.blue = 1.0; + color.alpha = 1.0; + break; + case 10: + color.red = 1.0; + color.green = 0.0; + color.blue = 0.5; + color.alpha = 1.0; + break; + case 11: + color.red = 0.0; + color.green = 1.0; + color.blue = 0.5; + color.alpha = 1.0; + break; + case 12: + color.red = 0.5; + color.green = 0.0; + color.blue = 1.0; + color.alpha = 1.0; + break; + case 13: + color.red = 1.0; + color.green = 0.5; + color.blue = 0.0; + color.alpha = 1.0; + break; + default: + color.red = 0.0+0.1*index; + color.green = 0.0+0.9*index; + color.blue = 0.0+0.5*index; + color.alpha = 1.0; + break; + } + return color; +} + + void on_window_destroy(GtkWidget *widget, gpointer data) { g_source_remove(GPOINTER_TO_UINT(data)); @@ -119,22 +220,43 @@ void utility_tools(GtkButton *but, gpointer udata) dimmension = 0; myParameters parameters = {utdata->util_map, g_red_image, g_green_image, g_last_image}; gpointer data = (gpointer)¶meters; - guint pid = g_timeout_add(20, (GSourceFunc)update_images, data); gtk_widget_set_size_request(GTK_WIDGET(utdata->util_map), 600, 500); gtk_container_add(utdata->map_layout, GTK_WIDGET(utdata->util_map)); // add live chart - serie = live_chart_serie_new("Hello", (LiveChartSerieRenderer*)live_chart_line_new (live_chart_values_new(10000))); + serie = live_chart_serie_new("IIT", (LiveChartSerieRenderer*)live_chart_line_new(live_chart_values_new(10000))); // live_chart set color to the serie - GdkRGBA color; - color.red = 1.0; - color.green = 0.0; - color.blue = 1.0; - color.alpha = 1.0; - + GdkRGBA color = getIndexColor(0); live_chart_path_set_color(live_chart_serie_get_line(serie), &color); + + // iterate over llptr and load the map_vis_head structure + + // vis_data_head = (struct map_vis_head *)malloc(sizeof(struct vis_data)); + + struct Lower_Layer_Details *llptr = LLfirst; + struct vis_data * visptr = vis_data_head; + int index = 0; + while (llptr != NULL) + { + visptr = (struct vis_data *)malloc(sizeof(struct vis_data)); + visptr->id = llptr->pmuid; + visptr->lat = llptr->latitude; + visptr->lon = llptr->longitude; + visptr->last_image = osm_gps_map_image_add(utdata->util_map, llptr->latitude, llptr->longitude, g_red_image); // TODO: change the image + visptr->serie = live_chart_serie_new(llptr->ip, (LiveChartSerieRenderer*)live_chart_line_new(live_chart_values_new(10000))); + // live_chart set color to the serie + GdkRGBA color = getIndexColor(index); + live_chart_path_set_color(live_chart_serie_get_line(visptr->serie), &color); + visptr->next = NULL; + visptr = visptr->next; + index++; + llptr = llptr->next; + } + + guint pid = g_timeout_add(20, (GSourceFunc)update_images, data); + LiveChartConfig *config = live_chart_config_new(); live_chart_yaxis_set_unit(config->y_axis, "mHz"); live_chart_xaxis_set_tick_interval(config->x_axis, 20); @@ -150,6 +272,7 @@ void utility_tools(GtkButton *but, gpointer udata) gtk_widget_set_size_request(GTK_WIDGET(chart), 600, 150); gtk_container_add(utdata->graph_layout, GTK_WIDGET(chart)); + From 4a2050f8c0aad9975f494b92067408ce5c50822b Mon Sep 17 00:00:00 2001 From: karthikmurakonda Date: Sat, 29 Oct 2022 15:58:45 +0530 Subject: [PATCH 5/6] added interactability --- iPDC/assets/utility_tools.ui | 816 ++++++++++++++++++++++++++++------ iPDC/assets/utility_tools.ui~ | 815 ++++++++++++++++++++++++++++----- iPDC/inc/utility_tools.h | 15 +- iPDC/src/utility_tools.c | 122 ++++- 4 files changed, 1506 insertions(+), 262 deletions(-) diff --git a/iPDC/assets/utility_tools.ui b/iPDC/assets/utility_tools.ui index 2989aee..2edcca0 100644 --- a/iPDC/assets/utility_tools.ui +++ b/iPDC/assets/utility_tools.ui @@ -3,8 +3,8 @@ - 900 - 700 + 985 + 800 False @@ -15,7 +15,7 @@ 3 - 800 + 900 True False True @@ -169,7 +169,7 @@ - + 100 80 @@ -309,7 +309,7 @@ - + 150 True False @@ -320,131 +320,538 @@ - + + True False - vertical - - True + False - Legend - True - - - False - True - 0 - - - - - - True - False - - - True - True - True - red - rgb(238,29,0) - - - 0 - 0 - - - - - True - False - Attack/Event - - - 1 - 0 - - - - - False - True - 1 - - - - - - True - False - - - True - True - True - rgb(0,255,0) - - - 0 - 0 - - + vertical True False - Normal + Legend + True - 1 - 0 + False + True + 0 + + + + True + False + + + True + True + True + red + rgb(238,29,0) + + + 0 + 0 + + + + + True + False + Attack/Event + + + 1 + 0 + + + + + False + True + 1 + + + + + + True + False + + + True + True + True + rgb(0,255,0) + + + 0 + 0 + + + + + True + False + Normal + + + 1 + 0 + + + + + False + True + 2 + + + + + + True + False + + + True + True + True + rgb(119,118,123) + + + 0 + 0 + + + + + True + False + No data + + + 1 + 0 + + + + + False + True + 3 + + + + + - False - True - 2 + 0 + 0 - - - True + False - - - True - True - True - rgb(119,118,123) - - - 0 - 0 - - + vertical True False - No data + Legend + True - 1 - 0 + False + True + 0 + + + + True + False + + + True + True + True + red + rgb(238,29,0) + + + 0 + 0 + + + + + True + False + >6900V + + + 1 + 0 + + + + + False + True + 1 + + + + + + True + False + + + True + True + True + rgb(0,255,0) + + + 0 + 0 + + + + + True + False + <6800V +<6300V + + + 1 + 0 + + + + + False + True + 2 + + + + + + True + False + + + True + True + True + rgb(119,118,123) + + + 0 + 0 + + + + + True + False + No data + + + 1 + 0 + + + + + False + True + 3 + + + + + - False - True - 3 + 1 + 0 - + + True + False + vertical + + + True + False + Legend + True + + + False + True + 0 + + + + + + True + False + + + True + True + True + red + rgb(238,29,0) + + + 0 + 0 + + + + + True + False + Deviation > 0.5 mHz + + + 1 + 0 + + + + + False + True + 1 + + + + + + True + False + + + True + True + True + rgb(0,255,0) + + + 0 + 0 + + + + + True + False + deviation < 0.5mHz + + + 1 + 0 + + + + + False + True + 2 + + + + + + True + False + + + True + True + True + rgb(119,118,123) + + + 0 + 0 + + + + + True + False + No data + + + 1 + 0 + + + + + False + True + 3 + + + + + + + + 2 + 0 + + + + + False + vertical + + + True + False + Legend + True + + + False + True + 0 + + + + + + True + False + + + True + True + True + red + rgb(238,29,0) + + + 0 + 0 + + + + + True + False + + + 1 + 0 + + + + + False + True + 1 + + + + + + True + False + + + True + True + True + rgb(0,255,0) + + + 0 + 0 + + + + + True + False + Normal + + + 1 + 0 + + + + + False + True + 2 + + + + + + True + False + + + True + True + True + rgb(119,118,123) + + + 0 + 0 + + + + + True + False + No data + + + 1 + 0 + + + + + False + True + 3 + + + + + + + + 3 + 0 + @@ -453,7 +860,28 @@ - + + 150 + True + False + + + 1 + 2 + + + + + 150 + False + + + 1 + 3 + + + + True True in @@ -462,7 +890,83 @@ True False - + + True + False + vertical + + + True + False + Graph Legend + + + False + True + 0 + + + + + + True + False + + + True + True + True + rgb(253,0,0) + + + 0 + 0 + + + + + True + False + RSS + + + 1 + 0 + + + + + False + True + 1 + + + + + + + + + + + + + + + 2 + 1 + + + + + True + in + + + True + False + + True False vertical @@ -488,7 +992,7 @@ True True True - rgb(255,120,0) + rgb(253,0,0) 0 @@ -499,7 +1003,7 @@ True False - Pmu + RSS 1 @@ -514,28 +1018,10 @@ - - True - True - True - - - False - True - 2 - + - - True - True - True - - - False - True - 3 - + @@ -544,9 +1030,91 @@ 2 - 1 + 2 + + + True + in + + + True + False + + + True + False + vertical + + + True + False + Graph Legend + + + False + True + 0 + + + + + + True + False + + + True + True + True + rgb(253,0,0) + + + 0 + 0 + + + + + True + False + RSS + + + 1 + 0 + + + + + False + True + 1 + + + + + + + + + + + + + + + 2 + 3 + + + + + + + + diff --git a/iPDC/assets/utility_tools.ui~ b/iPDC/assets/utility_tools.ui~ index 94ca09a..f0a7144 100644 --- a/iPDC/assets/utility_tools.ui~ +++ b/iPDC/assets/utility_tools.ui~ @@ -3,8 +3,8 @@ - 800 - 700 + 985 + 800 False @@ -15,7 +15,7 @@ 3 - 800 + 900 True False True @@ -169,7 +169,7 @@ - + 100 80 @@ -309,7 +309,7 @@ - + 150 True False @@ -320,131 +320,539 @@ - + + True False - vertical - + True False - Legend - True - - - False - True - 0 - - - - - - True - False - - - True - True - True - red - rgb(238,29,0) - - - 0 - 0 - - - - - True - False - Attack/Event - - - 1 - 0 - - - - - False - True - 1 - - - - - - True - False - - - True - True - True - rgb(0,255,0) - - - 0 - 0 - - + vertical True False - Normal + Legend + True - 1 - 0 + False + True + 0 + + + + True + False + + + True + True + True + red + rgb(238,29,0) + + + 0 + 0 + + + + + True + False + Attack/Event + + + 1 + 0 + + + + + False + True + 1 + + + + + + True + False + + + True + True + True + rgb(0,255,0) + + + 0 + 0 + + + + + True + False + Normal + + + 1 + 0 + + + + + False + True + 2 + + + + + + True + False + + + True + True + True + rgb(119,118,123) + + + 0 + 0 + + + + + True + False + No data + + + 1 + 0 + + + + + False + True + 3 + + + + + - False - True - 2 + 0 + 0 - - - True + False - - - True - True - True - rgb(119,118,123) - - - 0 - 0 - - + vertical True False - No data + Legend + True - 1 - 0 + False + True + 0 + + + + True + False + + + True + True + True + red + rgb(238,29,0) + + + 0 + 0 + + + + + True + False + >6900V + + + 1 + 0 + + + + + False + True + 1 + + + + + + True + False + + + True + True + True + rgb(0,255,0) + + + 0 + 0 + + + + + True + False + <6800V +<6300V + + + 1 + 0 + + + + + False + True + 2 + + + + + + True + False + + + True + True + True + rgb(119,118,123) + + + 0 + 0 + + + + + True + False + No data + + + 1 + 0 + + + + + False + True + 3 + + + + + - False - True - 3 + 1 + 0 - + + False + vertical + + + True + False + Legend + True + + + False + True + 0 + + + + + + True + False + + + True + True + True + red + rgb(238,29,0) + + + 0 + 0 + + + + + True + False + Attack/Event + + + 1 + 0 + + + + + False + True + 1 + + + + + + True + False + + + True + True + True + rgb(0,255,0) + + + 0 + 0 + + + + + True + False + Normal + + + 1 + 0 + + + + + False + True + 2 + + + + + + True + False + + + True + True + True + rgb(119,118,123) + + + 0 + 0 + + + + + True + False + No data + + + 1 + 0 + + + + + False + True + 3 + + + + + + + + 2 + 0 + + + + + False + vertical + + + True + False + Legend + True + + + False + True + 0 + + + + + + True + False + + + True + True + True + red + rgb(238,29,0) + + + 0 + 0 + + + + + True + False + Attack/Event + + + 1 + 0 + + + + + False + True + 1 + + + + + + True + False + + + True + True + True + rgb(0,255,0) + + + 0 + 0 + + + + + True + False + Normal + + + 1 + 0 + + + + + False + True + 2 + + + + + + True + False + + + True + True + True + rgb(119,118,123) + + + 0 + 0 + + + + + True + False + No data + + + 1 + 0 + + + + + False + True + 3 + + + + + + + + 3 + 0 + @@ -453,7 +861,28 @@ - + + 150 + True + False + + + 1 + 2 + + + + + 150 + False + + + 1 + 3 + + + + True True in @@ -462,7 +891,83 @@ True False - + + True + False + vertical + + + True + False + Graph Legend + + + False + True + 0 + + + + + + True + False + + + True + True + True + rgb(253,0,0) + + + 0 + 0 + + + + + True + False + RSS + + + 1 + 0 + + + + + False + True + 1 + + + + + + + + + + + + + + + 2 + 1 + + + + + True + in + + + True + False + + True False vertical @@ -488,7 +993,7 @@ True True True - rgb(255,120,0) + rgb(253,0,0) 0 @@ -499,7 +1004,7 @@ True False - Pmu + RSS 1 @@ -514,28 +1019,10 @@ - - True - True - True - - - False - True - 2 - + - - True - True - True - - - False - True - 3 - + @@ -544,9 +1031,91 @@ 2 - 1 + 2 + + + True + in + + + True + False + + + True + False + vertical + + + True + False + Graph Legend + + + False + True + 0 + + + + + + True + False + + + True + True + True + rgb(253,0,0) + + + 0 + 0 + + + + + True + False + RSS + + + 1 + 0 + + + + + False + True + 1 + + + + + + + + + + + + + + + 2 + 3 + + + + + + + + diff --git a/iPDC/inc/utility_tools.h b/iPDC/inc/utility_tools.h index 455bf27..425f8e1 100644 --- a/iPDC/inc/utility_tools.h +++ b/iPDC/inc/utility_tools.h @@ -20,12 +20,25 @@ struct _UtData /* ui buttons */ GtkWidget *voltage; GtkWidget *frequency; + GtkWidget *dfreq; GtkWidget *attack_detection; GtkWidget *algorithm; GtkWidget *dimmension; OsmGpsMap *util_map; GtkContainer *map_layout; - GtkContainer *graph_layout; + GtkContainer *graph_layoutvol; + GtkContainer *graph_layoutfreq; + GtkContainer *graph_layoutdfreq; + GtkLabel *algo_label; + GtkLabel *dimm_label; + GtkBox * ml_vol; + GtkBox * ml_freq; + GtkBox * ml_dfreq; + GtkBox * ml_ad; + GtkWidget *swvol; + GtkWidget *swfreq; + GtkWidget *swdfreq; + GtkWidget *swad; }; UtData *utdata; diff --git a/iPDC/src/utility_tools.c b/iPDC/src/utility_tools.c index 36db571..3db4ac9 100644 --- a/iPDC/src/utility_tools.c +++ b/iPDC/src/utility_tools.c @@ -126,44 +126,110 @@ void on_window_destroy(GtkWidget *widget, gpointer data) gtk_main_quit(); } +// on clicking the button voltage +void on_voltage_clicked(GtkButton *but, gpointer udata) +{ + curr_measurement = 0; + + gtk_widget_show(utdata->ml_vol); + gtk_widget_hide(utdata->ml_freq); + gtk_widget_hide(utdata->ml_dfreq); + gtk_widget_hide(utdata->ml_ad); + + gtk_widget_hide(utdata->algorithm); + gtk_widget_hide(utdata->dimmension); + gtk_widget_hide(utdata->algo_label); + gtk_widget_hide(utdata->dimm_label); + gtk_widget_set_sensitive(utdata->voltage, FALSE); + gtk_widget_set_sensitive(utdata->frequency, TRUE); + gtk_widget_set_sensitive(utdata->dfreq, TRUE); + gtk_widget_set_sensitive(utdata->attack_detection, TRUE); + printf("Voltage\n"); +} + // on clicking the button frequency void on_frequency_clicked(GtkButton *but, gpointer udata) { curr_measurement = 1; + + gtk_widget_show(utdata->ml_freq); + gtk_widget_hide(utdata->ml_vol); + gtk_widget_hide(utdata->ml_dfreq); + gtk_widget_hide(utdata->ml_ad); + gtk_widget_hide(utdata->algorithm); gtk_widget_hide(utdata->dimmension); + gtk_widget_hide(utdata->algo_label); + gtk_widget_hide(utdata->dimm_label); gtk_widget_set_sensitive(utdata->voltage, TRUE); gtk_widget_set_sensitive(utdata->frequency, FALSE); + gtk_widget_set_sensitive(utdata->dfreq, TRUE); gtk_widget_set_sensitive(utdata->attack_detection, TRUE); printf("Frequency\n"); } +// on clicking the button dfreq +void on_dfreq_clicked(GtkButton *but, gpointer udata) +{ + curr_measurement = 2; + + gtk_widget_show(utdata->ml_dfreq); + gtk_widget_hide(utdata->ml_vol); + gtk_widget_hide(utdata->ml_freq); + gtk_widget_hide(utdata->ml_ad); + + + gtk_widget_hide(utdata->algorithm); + gtk_widget_hide(utdata->dimmension); + gtk_widget_hide(utdata->algo_label); + gtk_widget_hide(utdata->dimm_label); + gtk_widget_set_sensitive(utdata->voltage, TRUE); + gtk_widget_set_sensitive(utdata->frequency, TRUE); + gtk_widget_set_sensitive(utdata->dfreq, FALSE); + gtk_widget_set_sensitive(utdata->attack_detection, TRUE); + + printf("dfreq\n"); +} + // on clicking the button attack_detection void on_attack_detection_clicked(GtkButton *but, gpointer udata) { - curr_measurement = 2; + curr_measurement = 3; gtk_widget_set_sensitive(utdata->voltage, TRUE); gtk_widget_set_sensitive(utdata->frequency, TRUE); + gtk_widget_set_sensitive(utdata->dfreq, TRUE); gtk_widget_set_sensitive(utdata->attack_detection, FALSE); gtk_widget_show(utdata->algorithm); gtk_widget_show(utdata->dimmension); + gtk_widget_show(utdata->algo_label); + gtk_widget_show(utdata->dimm_label); + gtk_widget_show(utdata->ml_ad); + + gtk_widget_hide(utdata->ml_vol); + gtk_widget_hide(utdata->ml_freq); + gtk_widget_hide(utdata->ml_dfreq); + printf("Attack Detection\n"); } -// on clicking the button voltage -void on_voltage_clicked(GtkButton *but, gpointer udata) +void set_algo(GtkComboBox *combo, gpointer udata) { - curr_measurement = 0; - gtk_widget_hide(utdata->algorithm); - gtk_widget_hide(utdata->dimmension); - gtk_widget_set_sensitive(utdata->voltage, FALSE); - gtk_widget_set_sensitive(utdata->frequency, TRUE); - gtk_widget_set_sensitive(utdata->attack_detection, TRUE); - printf("Voltage\n"); + algorithm = gtk_combo_box_get_active(combo); + printf("Algorithm: %d\n", algorithm); } +void set_dimm(GtkComboBox *combo, gpointer udata) +{ + dimmension = gtk_combo_box_get_active(combo); + + printf("dimmension = %d\n", dimmension); +} + + + + void utility_tools(GtkButton *but, gpointer udata) { GdkPixbuf *g_red_image; @@ -184,20 +250,40 @@ void utility_tools(GtkButton *but, gpointer udata) utdata->util_window = GTK_WIDGET(gtk_builder_get_object(builder, "util_window")); utdata->voltage = GTK_WIDGET(gtk_builder_get_object(builder, "voltage")); utdata->frequency = GTK_WIDGET(gtk_builder_get_object(builder, "freq")); + utdata->dfreq = GTK_WIDGET(gtk_builder_get_object(builder, "dfreq")); utdata->attack_detection = GTK_WIDGET(gtk_builder_get_object(builder, "attack_detection")); utdata->algorithm = GTK_WIDGET(gtk_builder_get_object(builder, "algorithm")); utdata->dimmension = GTK_WIDGET(gtk_builder_get_object(builder, "dimmension")); // utdata->util_map = GTK_WIDGET(gtk_builder_get_object(builder, "util_map")); utdata->map_layout = GTK_CONTAINER(gtk_builder_get_object(builder, "map_layout")); - utdata->graph_layout = GTK_CONTAINER(gtk_builder_get_object(builder, "graph_layout")); + utdata->graph_layoutvol = GTK_CONTAINER(gtk_builder_get_object(builder, "graph_layoutvol")); + utdata->graph_layoutfreq = GTK_CONTAINER(gtk_builder_get_object(builder, "graph_layoutfreq")); + utdata->graph_layoutdfreq = GTK_CONTAINER(gtk_builder_get_object(builder, "graph_layoutdfreq")); + utdata->algo_label = GTK_WIDGET(gtk_builder_get_object(builder, "algo_label")); + utdata->dimm_label = GTK_WIDGET(gtk_builder_get_object(builder, "dimm_label")); + utdata->ml_vol = GTK_WIDGET(gtk_builder_get_object(builder, "mlvol")); + utdata->ml_freq = GTK_WIDGET(gtk_builder_get_object(builder, "mlfreq")); + utdata->ml_dfreq = GTK_WIDGET(gtk_builder_get_object(builder, "mldfreq")); + utdata->ml_ad = GTK_WIDGET(gtk_builder_get_object(builder, "mlad")); + utdata->swvol = GTK_WIDGET(gtk_builder_get_object(builder, "swvol")); + utdata->swfreq = GTK_WIDGET(gtk_builder_get_object(builder, "swfreq")); + utdata->swdfreq = GTK_WIDGET(gtk_builder_get_object(builder, "swdfreq")); + utdata->swad = GTK_WIDGET(gtk_builder_get_object(builder, "swad")); gtk_widget_set_sensitive(utdata->voltage, FALSE); gtk_widget_set_visible(utdata->algorithm, FALSE); gtk_widget_set_visible(utdata->dimmension, FALSE); - g_signal_connect(utdata->attack_detection, "clicked", G_CALLBACK(on_attack_detection_clicked), NULL); - g_signal_connect(utdata->frequency, "clicked", G_CALLBACK(on_frequency_clicked), NULL); + gtk_widget_set_visible(utdata->graph_layoutfreq, FALSE); + gtk_widget_set_visible(utdata->graph_layoutdfreq, FALSE); + + g_signal_connect(utdata->voltage, "clicked", G_CALLBACK(on_voltage_clicked), NULL); + g_signal_connect(utdata->frequency, "clicked", G_CALLBACK(on_frequency_clicked), NULL); + g_signal_connect(utdata->dfreq, "clicked", G_CALLBACK(on_dfreq_clicked), NULL); + g_signal_connect(utdata->attack_detection, "clicked", G_CALLBACK(on_attack_detection_clicked), NULL); + g_signal_connect(utdata->algorithm, "changed", G_CALLBACK(set_algo), NULL); + g_signal_connect(utdata->dimmension, "changed", G_CALLBACK(set_dimm), NULL); g_red_image = gdk_pixbuf_new_from_file_at_size(RED_IMAGE, 24, 24, NULL); g_green_image = gdk_pixbuf_new_from_file_at_size(GREEN_IMAGE, 24, 24, NULL); @@ -271,7 +357,7 @@ void utility_tools(GtkButton *but, gpointer udata) // gtk_widget_set_vexpand(GTK_WIDGET(chart), TRUE); gtk_widget_set_size_request(GTK_WIDGET(chart), 600, 150); - gtk_container_add(utdata->graph_layout, GTK_WIDGET(chart)); + gtk_container_add(utdata->graph_layoutvol, GTK_WIDGET(chart)); @@ -290,6 +376,14 @@ void utility_tools(GtkButton *but, gpointer udata) gtk_widget_hide(utdata->algorithm); gtk_widget_hide(utdata->dimmension); + gtk_widget_hide(utdata->algo_label); + gtk_widget_hide(utdata->dimm_label); + gtk_widget_hide(utdata->ml_freq); + gtk_widget_hide(utdata->ml_dfreq); + gtk_widget_hide(utdata->ml_ad); + gtk_widget_hide(utdata->swfreq); + gtk_widget_hide(utdata->swdfreq); + gtk_widget_hide(utdata->swad); gtk_main(); } \ No newline at end of file From 0a45563c3f1f4f0a5af4d964e000566d4a824ad0 Mon Sep 17 00:00:00 2001 From: pavanvpatil Date: Sat, 29 Oct 2022 16:52:19 +0530 Subject: [PATCH 6/6] corrected somethings in algo --- iPDC/src/Attack_detect.c | 4 ++ iPDC/src/Kmeans.c | 119 ++++++++++++++++++++++++++------------- 2 files changed, 85 insertions(+), 38 deletions(-) diff --git a/iPDC/src/Attack_detect.c b/iPDC/src/Attack_detect.c index 51c6699..7dfd2ca 100644 --- a/iPDC/src/Attack_detect.c +++ b/iPDC/src/Attack_detect.c @@ -34,6 +34,7 @@ gboolean attack_detect_freq(struct data_frame *df) head = (struct freqlist *)malloc(sizeof(struct freqlist)); head->AVERAGE_OF_FREQUENCY = 50; head->COUNT = 500; + head->idcode=to_intconvertor(df->idcode); return TRUE; } else @@ -83,6 +84,7 @@ gboolean attack_detect_freq(struct data_frame *df) bring = (struct freqlist *)malloc(sizeof(struct freqlist)); bring->AVERAGE_OF_FREQUENCY = 50; bring->COUNT = 500; + bring->idcode = to_intconvertor(df->idcode); previous->next=bring; return TRUE; } @@ -117,6 +119,7 @@ gboolean attack_detect_vol(struct data_frame *df) headvol = (struct vollist *)malloc(sizeof(struct vollist)); headvol->AVERAGE_OF_VOLTAGE = CURR_vol; headvol->COUNT = 500; + headvol->idcode=to_intconvertor(df->idcode); return TRUE; } else @@ -160,6 +163,7 @@ gboolean attack_detect_vol(struct data_frame *df) bring->AVERAGE_OF_VOLTAGE = CURR_vol; bring->COUNT = 500; previous->next = bring; + bring->idcode = to_intconvertor(df->idcode); return TRUE; } } diff --git a/iPDC/src/Kmeans.c b/iPDC/src/Kmeans.c index 11e5605..1fd95b7 100644 --- a/iPDC/src/Kmeans.c +++ b/iPDC/src/Kmeans.c @@ -6,53 +6,96 @@ #include #include -FILE *fp; -/*intial weights weights for each points */ -unsigned long long int count_A = 1000; -unsigned long long int count_B = 1000; -unsigned long long int count_C = 1000; +// FILE *fp; -/*In India frequency ranges from 49.5 to 50.2 Hz*/ -long double std_dev = 0.6454972244; -long double A = 0; // for point A=50 -long double B = -1.5491933394; // for point B=49 -long double C = 0.7745966692; // for point C=50.5 -long double mean = 50; -unsigned long long int count = 3000; +struct kmeans1 +{ + int idcode; + unsigned long long int count_A = 1000; + unsigned long long int count_B = 1000; + unsigned long long int count_C = 1000; + long double A = 50; + long double B = 49; + long double C = 51; + struct kmeans1 *next; +} + +struct kmeans1 *headk = NULL; gboolean kmeans(struct data_frame *df) { - long double CURR_FREQ = 50 + to_intconvertor(df->dpmu[0]->freq) * 1e-3; - long double CURR_FREQ_temp = CURR_FREQ; - CURR_FREQ = (CURR_FREQ - mean) / std_dev; - long double diff_A = fabs(A - CURR_FREQ); - long double diff_B = fabs(B - CURR_FREQ); - long double diff_C = fabs(C - CURR_FREQ); - // fp = fopen("points.csv","a"); - // printf("A: %Lf, B: %Lf, C: %Lf\n",A,B,C); - // fprintf(fp,"%Lf, %Lf, %Lf\n",A,B,C); - // fclose(fp); - - /*Updating std_dev and mean*/ - // printf("std_dev: %Lf, mean: %Lf\n",std_dev,mean); - mean = ((mean * count) + CURR_FREQ_temp) / (++count); - std_dev = (((std_dev * std_dev) * (count - 1)) + (CURR_FREQ * std_dev * CURR_FREQ * std_dev)) / count; - std_dev = sqrt(std_dev); - - if (diff_A <= diff_B && diff_A <= diff_C) + if (headk == NULL) { - A = ((count_A * (A)) + CURR_FREQ) / (++count_A); + headk->A = 50; + headk->B = 49; + headk->C = 51; + headk->count_A = 1000; + headk->count_B = 1000; + headk->count_C = 1000; + headk->next = NULL; + headk->idcode = to_intconvertor(df->idcode); return TRUE; } - else if (diff_B < diff_C) - { - B = ((count_B * (B)) + CURR_FREQ) / (++count_B); - return FALSE; - } else { - C = ((count_C * (C)) + CURR_FREQ) / (++count_C); - return FALSE; + struct kmeans1 *temp == headk; + struct kmeans1 *previous == NULL; + while (temp != NULL) + { + if (temp->idcode == to_intconvertor(df->idcode)) + { + float CURR_FREQ; + if (df->dpmu[0]->fmt->freq == '0') + { + CURR_FREQ = 50 + to_intconvertor(df->dpmu[0]->freq) * 1e-3; + } + else + { + CURR_FREQ = decode_ieee_single(df->dpmu[0]->freq); + } + + long double diff_A = fabs(temp->A - CURR_FREQ); + long double diff_B = fabs(temp->B - CURR_FREQ); + long double diff_C = fabs(temp->C - CURR_FREQ); + // fp = fopen("points.csv","a"); + // printf("A: %Lf, B: %Lf, C: %Lf\n",A,B,C); + // fprintf(fp,"%Lf, %Lf, %Lf\n",A,B,C); + // fclose(fp); + + if (diff_A <= diff_B && diff_A <= diff_C) + { + temp->A = ((temp->count_A * (temp->A)) + CURR_FREQ) / (++temp->count_A); + return TRUE; + } + else if (diff_B < diff_C) + { + temp->B = ((temp->count_B * (temp->B)) + CURR_FREQ) / (++temp->count_B); + return FALSE; + } + else + { + temp->C = ((temp->count_C * (temp->C)) + CURR_FREQ) / (++temp->count_C); + return FALSE; + } + break; + } + previous=temp; + temp = temp->next; + } + if(temp==NULL) + { + struct kmeans1 *bring = (struct kmeans1 *)malloc(sizeof(struct kmeans1)); + bring->A = 50; + bring->B = 49; + bring->C = 51; + bring->count_A = 1000; + bring->count_B = 1000; + bring->count_C = 1000; + bring->next = NULL; + bring->idcode = to_intconvertor(df->idcode); + previous->next=bring; + return TRUE; + } } }