Traitement-signal-plantes/Code-C/simulateFlux.c

#include "simulateFlux.h"
#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
    int m = N;
    int digit = 0;
    while (m) {
        digit++;
        m /= 10;
    }
    char* arr;
    char arr1[digit];
    arr = (char*)malloc(digit*sizeof(char));
    int index = 0;
    while (N) {
        arr1[++index] = N % 10 + '0';
        N /= 10;
    }
    int i;
    for (i = 0; i < index; i++) {
        arr[i] = arr1[index - i];
    }
    arr[i] = '\0';
    return (char*)arr;
}

/**
 * @brief Create a New Raw Data File Name 
 * 
 * @return char* 
 */
char *createNewRawDataFileName(){
    char *fileName  = "../RawDataFiles/RawData";
    char *extension = ".csv\0";
    char *fileNumber = convertIntegerToChar(cptFile);
    //char *fileNumber;
    //sprintf(fileNumber, "%d", cptFile);
    //printf("%s\n" , fileNumber);

    char fileNameNumber[strlen(fileName)+strlen(fileNumber)];
    char *fullFileName = malloc((strlen(fileNameNumber)+strlen(extension)) * sizeof(char*));

    strcpy( fileNameNumber, fileName );
    strcat( fileNameNumber, fileNumber );

    strcpy( fullFileName, fileNameNumber );
    strcat( fullFileName, extension );
    
    return fullFileName;
}

int intInArray(int number , int *array , int N){
    for(int i  = 0 ; i < N ; i++){
        if(array[i] == number) return 0; 
    }
    return -1;
}
int maxInArray(int *array , int N){
    int max  = 0;
    for(int i = 0 ; i < N ; i++){
        if(array[i]>max) max  = array[i];
    }
    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;
}


int lastIndexCaptor(){
    int lastIndex = 0;
    for(int i = 1 ; i < 8 ; i++){
        if(selectionCaptors[i]){
            lastIndex = i;
        }
    }
    return lastIndex;
}

/**
 * @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];
    int32_t values[8];
    uint32_t valbin[8];
    quartet value;

    if(fread(&buff, 26, 1, stdin)) {
        //printf("%d\n",cptValue);
        if(cptValue < nbRowBinFile - nbRowIgnore){
            FILE *timeFile = fopen("timeFile.csv" , "a+");
            fprintf(timeFile , "%ld\n", millis());
            fclose(timeFile);
            fprintf(rawDataFile , "%ld,", millis());
            if (strncmp(buff, "#################\n", (size_t)18) == 0) {
                if (!(fread(&buff2, 18, 1, stdin))) {
                    fprintf(stderr, "Erreur lecture après ###...#");
                } else {
                    strncpy(buff, &buff[18], 8);
                    strncpy(&buff[8], buff2, 18);
                }
            }
            int lastIndex = lastIndexCaptor();
            for (int i = 1; i < 9; i++){
                if(selectionCaptors[i-1]){
                    value.octet1 = buff[3*i+1];
                    value.octet2 = buff[3*i+2];
                    value.octet3 = buff[3*i+3];
                    value.octet4 = 0;
                    
                    valbin[i] = buff[3*i+1]*256*256*256 + buff[3*i+2]*256*256 + buff[3*i+3]*256;
                    memcpy(&values[i], &valbin[i], sizeof(uint32_t));
                    FILE* allRawDataFile = fopen("AllRawData.csv" , "a+");
                    if(i-1==lastIndex){
                        fprintf(rawDataFile, "%d\n", values[i]/256);
                        fprintf(allRawDataFile, "%d\n", values[i]/256);
                    }
                    else{
                        fprintf(rawDataFile, "%d,", values[i]/256);
                        fprintf(allRawDataFile, "%d,", values[i]/256);
                    }
                    fclose(allRawDataFile); 
                }
            }
        cptData++;
        //sleep(0.004); //simul freq here

        cptValue++;
        return true;
        } 
        else {
            return false;
        }
    }
}

void *threadSimulateFlux(void *vargp){

    char *fileName = createNewRawDataFileName();
    FILE *rawDataFile = fopen(fileName,"w+");

    while(writeOneRawData(rawDataFile)){
        if(cptData == nRowRawData){
            fclose(rawDataFile);
            cptData = 0;
            cptFile++;
            //create struct here
            queueAddLastQ(firstRawDataQueue , fileName , strlen(fileName));
            //prepare next file now
            fileName = createNewRawDataFileName();
            FILE *rawDataFile = fopen(fileName,"w+");
        }
    }
    rawDataWriteFlag = false;
}