Merge branch 'SimulFlux'

Code-C/Makefile

@@ -1,7 +1,7 @@
 CC = gcc
 
 all: 
-	$(CC) fileGestion.c getArray.c power.c queue.c simulateFlux.c main.c -lm -lpthread -o main 
+	$(CC) fileGestion.c getArray.c average.c power.c queue.c simulateFlux.c main.c -lm -lpthread -o main 
 
 #	$(CC) queue.c simulateFlux.c main.c -lm -lpthread -o main 
 	./main < ../02400031.TXT

Code-C/average.c

@@ -0,0 +1,42 @@
+#include "average.h"
+#include "getArray.h"
+#include "fileGestion.h"
+#include "initialParameters.h"
+#include "queue.h"
+/**
+ * @brief realize the average calcul
+ * 
+ * @param p array with all the values that will be used for the calcul
+ * @param averageArray array where results are stocked
+ * @param N number of rows in p
+ * @param M number of columns in p
+ */
+void averageCalculation(long **p, double averageArray[] , int N, int M){
+    for(int i = 0; i < M-1; i++){
+        int j = 0;
+        averageArray[i] = 0;
+        while(j < N){
+            averageArray[i] += p[i][j];
+            j++;
+        }
+        averageArray[i] /= N;
+        //printf("%f\n", powerArray[i]);
+    }
+}
+
+/**
+ * @brief function that realize all the action to write one lign in the file averageData.csv
+ * 
+ * @param rawDataFileName name of the raw data file to use to realize the calcul
+ * @param N number of rows in the file
+ * @param M number of columns in the file
+ */
+void average(char* rawDataFileName,int N , int M){
+    long **p = getRawDataArray(rawDataFileName,N, M);
+    double aver[8];
+    if(p !=NULL){
+        averageCalculation(p,aver,N,M);
+        writeDataInFile("averageData.csv",aver,8);
+        freeArray(p,N);
+    }
+}

Code-C/average.h

@@ -0,0 +1,4 @@
+#include <math.h>
+#include <stdbool.h>
+
+void average(char* rawDataFileName,int N , int M);

Code-C/b2hd.c

@@ -43,6 +43,8 @@ void b2hd()
     }
   }
 }
+
+
 int main(int argc , char** argv){
   b2hd();
 }

Code-C/fileGestion.c

@@ -21,18 +21,18 @@ void clearRawData(int nRow){
     fclose(f); fclose(g);
 }
 /**
- * @brief use to write the file powerData.csv that contaign all power calculous results
+ * @brief use to write one lign in the file "fileName"
  * 
- * @param powerArray
- * @param nCol size of the power array, correspond to the number of captor used
+ * @param array array that contaign all the values to write in the file
+ * @param nCol size of the array (correspond to the number of captor used)
  */
-void writePowerData(double powerArray[], int nCol){
-    FILE *f = fopen("powerData.csv","a+");
+void writeDataInFile(char* fileName , double array[], int nCol){
+    FILE *f = fopen(fileName,"a+");
     for(int i = 0 ; i < nCol ; i++){
         if( i < nCol-1){
-            fprintf(f, "%f , ", powerArray[i]);
+            fprintf(f, "%f , ", array[i]);
         } else {
-            fprintf(f, "%f\n", powerArray[i]);
+            fprintf(f, "%f\n", array[i]);
         }
     }
     fclose(f);

Code-C/fileGestion.h

@@ -5,4 +5,4 @@
 
 
 void clearRawData(int N);
-void writePowerData(double a[], int N);
+void writeDataInFile(char* fileName , double a[], int N);

Code-C/getArray.c

@@ -15,27 +15,23 @@ long **get(int N, int M) /* Allocate the array */
 
 void fillArrayWithRawData(char *rawDataFileName,long** p, int N, int M) {
     int i, j;
-
     char *buffer;
     size_t bufsize = 200;
     buffer = (char *)malloc(bufsize * sizeof(char));
     char* token;
 
     FILE *f = fopen(rawDataFileName,"r");
+
     for(i = 0 ; i < N ; i++){
         if (!getline(&buffer, &bufsize, f)) break; // condition d'arret de la boucle si fichier fini
-        //printf("buffer : %s token : ",buffer);
         j = 0;
         while((token = strsep(&buffer,",")) != NULL){     // séparation valeur par virgule initiale : csv
-            //printf(token);
             p[i][j] = atoi(token);
-            //printf("%d,", p[i][j]);
-            //printf("%d, " , p[i][j]);
             j++;
         }
-        //printf("\n\n");
     }
     fclose(f);
+
 }
 /**
  * @brief print all the element of a bidimensionnal array p of shape : N x M
@@ -53,10 +49,11 @@ void printArrayData(long** p, int N, int M) {
 /**
  * @brief verify if all the element of an array are not NULL, return 
  * 
- * @param p 
- * @param N 
- * @param M 
- * @return int 
+ * @param p array to check
+ * @param N number of rows in p
+ * @param M number of columns in p
+ * @return true if the array contaign no NULL element
+ * @return false if at least one element is null
  */
 bool checkArrayFullyFill(long **p, int N , int M){
     for(int i  = 0 ; i < N ; i++){
@@ -65,6 +62,12 @@ bool checkArrayFullyFill(long **p, int N , int M){
     return true;
 }
 
+/**
+ * @brief free memory allocate to an array p
+ * 
+ * @param p array to free memory
+ * @param N number of rows in array
+ */
 void freeArray(long **p, int N) {
     int i;
     for(i = 0 ; i < N ; i++)
@@ -72,18 +75,23 @@ void freeArray(long **p, int N) {
     free(p);
 }
 
+/**
+ * @brief Get the Raw Data Array object
+ * 
+ * @param rawDataFileName name of the file to use to file the array
+ * @param N numbers of rows to have i the array
+ * @param M numbers of columns to have i the array
+ * @return long** the array fill with raw data
+ */
 long **getRawDataArray(char* rawDataFileName , int N , int M){
     long **p;
     p = get(N, M);
     fillArrayWithRawData(rawDataFileName,p ,N, M);
-    //printf("before  test\n");
-    if(checkArrayFullyFill(p,N,M)==0){
-        //printf("after test 0\n");
-        clearRawData(N);
+    if(checkArrayFullyFill(p,N,M)){
+        //clearRawData(N);
         return p;
     }
     else{
-        //printf("after test 1\n");
         return NULL;
     }
 }

Code-C/initialParameters.h

@@ -1,7 +1,7 @@
 #include <stdbool.h>
 #include "queue.h"
 
-extern bool rawDataWriteFlag , stopFlag;
+extern bool rawDataWriteFlag;
 extern int nRow;
 extern int nCol;
 extern double freqEch;

Code-C/main.c

@@ -4,9 +4,10 @@
 #include "power.h"
 #include "initialParameters.h"
 #include "queue.h"
+#include "average.h"
 
-bool rawDataWriteFlag = 0, stopFlag = 0;
-int nRow = 100000;
+bool rawDataWriteFlag;
+int nRow = 500;
 int nCol = 9;
 double freqEch = 250;
 
@@ -21,31 +22,59 @@ int cptFile = 1;
 double period = 0;
 double invTimeBandWidth = 0;
 
-void *threadCalcul(void *vargp){
-    printf("start thread calcul\n");
+void *threadCalculPower(void *vargp){
     Pqueue rawDataQueue = firstRawDataQueue;
-    while(queueGetNextE(rawDataQueue) != NULL){
-            printf("wile calcul\n");
-            //pthread_mutex_lock(&mutex); 
-            power(queueGetTabChar(rawDataQueue),nRow,nCol,period,invTimeBandWidth);
-                /*remove(queueGetTabChar(rawDataQueue));
-                rawDataQueue = queueRmFrstE(rawDataQueue);*/
-            
-            //pthread_mutex_unlock(&mutex);
+    char* fileName;
+    while(rawDataWriteFlag){
+        while(queueGetNextE(rawDataQueue) != NULL){
+            rawDataQueue = queueGetNextE(rawDataQueue);
+            fileName = queueGetTabChar(rawDataQueue);
+            power(fileName,nRow,nCol,period,invTimeBandWidth);
+            remove(fileName);
+        }
+    }
+}
+
+void *threadCalculAverage(void *vargp){
+    Pqueue rawDataQueue = firstRawDataQueue;
+    char* fileName;
+    while(rawDataWriteFlag){
+        while(queueGetNextE(rawDataQueue) != NULL){
+            rawDataQueue = queueGetNextE(rawDataQueue);
+            fileName = queueGetTabChar(rawDataQueue);
+            average(fileName,nRow,nCol);
+            remove(fileName);
+        }
+    }
+}
+
+void *threadCalculBoth(void *vargp){
+    Pqueue rawDataQueue = firstRawDataQueue;
+    char* fileName;
+    while(rawDataWriteFlag){
+        while(queueGetNextE(rawDataQueue) != NULL){
+            rawDataQueue = queueGetNextE(rawDataQueue);
+            fileName = queueGetTabChar(rawDataQueue);
+            power(fileName,nRow,nCol,period,invTimeBandWidth);
+            average(fileName,nRow,nCol);
+            remove(fileName);
+        }
     }
 }
 
 int main(int argc , char** argv){
 
+    rawDataWriteFlag = true;
+
     period = 1 / freqEch;
     invTimeBandWidth = 1 /(nRow * period);
     firstRawDataQueue = queueCreateEmpty(); // change this for create empty
     
     pthread_t rawData;
-    pthread_create(&rawData , NULL, simulateFlux, (void *)&rawData);
+    pthread_create(&rawData , NULL, threadSimulateFlux, (void *)&rawData);
 
-    //pthread_t calcul;
-    //pthread_create(&calcul , NULL, threadCalcul, (void *)&calcul);
+    pthread_t calcul;
+    pthread_create(&calcul , NULL, threadCalculBoth, (void *)&calcul);
 
     pthread_exit(NULL);
 }

Code-C/power.c

@@ -4,6 +4,14 @@
 #include "initialParameters.h"
 #include "queue.h"
 
+/**
+ * @brief realize the power calcul
+ * 
+ * @param p array with all the values that will be used for the calcul
+ * @param powerArray array where results are stocked
+ * @param N number of rows in p
+ * @param M number of columns in p
+ */
 void powerCalculation(long **p, double powerArray[] , int N, int M , double period , double invTimeBandwidth){
     for(int i = 0; i < M-1; i++){
         int j = 0;
@@ -18,12 +26,20 @@ void powerCalculation(long **p, double powerArray[] , int N, int M , double peri
         //printf("%f\n", powerArray[i]);
     }
 }
+
+/**
+ * @brief function that realize all the action to write one lign in the file powerData.csv
+ * 
+ * @param rawDataFileName name of the raw data file to use to realize the calcul
+ * @param N number of rows in the file
+ * @param M number of columns in the file
+ */
 bool power(char* rawDataFileName,int N , int M, double periode , double invTimeBandwidth){
     long **p = getRawDataArray(rawDataFileName,N, M);
     double pw[8];
     if(p !=NULL){
         powerCalculation(p,pw,N,M,periode,invTimeBandwidth);
-        writePowerData(pw,8);
+        writeDataInFile("powerData.csv",pw,8);
         freeArray(p,N);
         return true;
     }

Code-C/power.h

@@ -1,5 +1,4 @@
 #include <math.h>
 #include <stdbool.h>
 
-bool power(char* rawDataFileName,int N , int M, double periode , double invTimeBandwidth);
-void *threadCalcul(void *vargp);
+bool power(char* rawDataFileName,int N , int M, double periode , double invTimeBandwidth);

Code-C/queue.c

@@ -148,14 +148,11 @@ Pqueue queueRmLastE(Pqueue elem){
  * @brief remove and free the first element of queue
  * 
  * @param elem target to remove (the element need to be the first)
- * @return Pqueue the second element after remove first
  */
-Pqueue queueRmFrstE(Pqueue elem){
+void queueRmFrstE(Pqueue elem){
     assert(elem);
-    Pqueue tmp = elem->pNextE;
     free(elem->tabChar);
     free(elem);
-    return tmp;
 }
 
 /**
@@ -177,7 +174,6 @@ Pqueue queueNextDelFrst(Pqueue elem){
  * @param elem Pqueue will be added at the end of queue
  * @param str the string will be bind at the element
  * @param len the lenght of char array
- * @return Pqueue pointer to the last element
  */
 void queueAddLastQ(Pqueue elem, const char* str, int len){
     assert(elem);
@@ -208,6 +204,11 @@ void queuePrintE(Pqueue elem){
     }
 }
 
+/**
+ * @brief Print all the element starting from @param firstE till the end of the linked list
+ * 
+ * @param firstE 
+ */
 void queuePrintWholeQ(Pqueue firstE){
     queuePrintE(firstE);
     Pqueue elem = firstE;

Code-C/queue.h

@@ -19,7 +19,7 @@ void queueAddLastQ(Pqueue elem, const char* str, int len);
 
 //Removers
 Pqueue queueRmLastE(Pqueue elem);
-Pqueue queueRmFrstE(Pqueue elem);
+void queueRmFrstE(Pqueue elem);
 Pqueue queueNextDelFrst(Pqueue elem);
 
 //print function

Code-C/simulateFlux.c

@@ -2,7 +2,12 @@
 #include "initialParameters.h"
 #include "queue.h"
 
-
+/**
+ * @brief convert an interger N into a char*
+ * 
+ * @param N 
+ * @return char* 
+ */
 char* convertIntegerToChar(int N)
 {
     // Count digits in number N
@@ -28,6 +33,11 @@ char* convertIntegerToChar(int N)
     return (char*)arr;
 }
 
+/**
+ * @brief Create a New Raw Data File Name 
+ * 
+ * @return char* 
+ */
 char *createNewRawDataFileName(){
     char *fileName  = "../RawDataFiles/RawData";
     char *extension = ".csv\0";
@@ -58,13 +68,25 @@ int maxInArray(int *array , int N){
     }
     return max;
 }
-
+/**
+ * @brief return the unix time in millisecond
+ * 
+ * @return int64_t 
+ */
 int64_t millis()
 {
     struct timespec now;
     timespec_get(&now, TIME_UTC);
     return ((int64_t) now.tv_sec) * 1000 + ((int64_t) now.tv_nsec) / 1000000;
 }
+
+/**
+ * @brief write one lign of rawData in the file @param rawDataFile (simulate of freq of the Vegetal Signals Captor)
+ * 
+ * @param rawDataFile 
+ * @return true if the lign is correctly write , else :
+ * @return false 
+ */
 bool writeOneRawData(FILE *rawDataFile){
     char buff[26];
     char buff2[18];
@@ -105,7 +127,7 @@ bool writeOneRawData(FILE *rawDataFile){
             }
         }
     cptData++;
-    //sleep(0.004); //simul la freq ech
+    //sleep(0.004); //simul freq here
     return true;
     } 
     else {
@@ -113,8 +135,7 @@ bool writeOneRawData(FILE *rawDataFile){
     }
 }
 
-void *simulateFlux(void *vargp){
-    printf("start thread simul\n");
+void *threadSimulateFlux(void *vargp){
 
     char *fileName = createNewRawDataFileName();
     FILE *rawDataFile = fopen(fileName,"w+");
@@ -131,5 +152,5 @@ void *simulateFlux(void *vargp){
             FILE *rawDataFile = fopen(fileName,"w+");
         }
     }
-    queuePrintWholeQ(firstRawDataQueue);
+    rawDataWriteFlag = false;
 }

Code-C/simulateFlux.h

@@ -18,4 +18,4 @@ extern int cptFile;
 
 char *convertIntegerToChar(int N);
 bool writeOneRawData(FILE *f);
-void *simulateFlux(void *vargp);
+void *threadSimulateFlux(void *vargp);