TRestRawMemoryBufferToSignalProcess.cxx

/*************************************************************************
 * This file is part of the REST software framework.                     *
 *                                                                       *
 * Copyright (C) 2016 GIFNA/TREX (University of Zaragoza)                *
 * For more information see http://gifna.unizar.es/trex                  *
 *                                                                       *
 * REST 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 3 of the License, or     *
 * (at your option) any later version.                                   *
 *                                                                       *
 * REST 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 a copy of the GNU General Public License along with   *
 * REST in $REST_PATH/LICENSE.                                           *
 * If not, see http://www.gnu.org/licenses/.                             *
 * For the list of contributors see $REST_PATH/CREDITS.                  *
 *************************************************************************/
 
#include "TRestRawMemoryBufferToSignalProcess.h"
 
using namespace std;
 
#include <sys/sem.h>
#include <sys/shm.h>
 
#ifdef __APPLE__
#include <unistd.h>
#endif
 
#if (defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)) || __APPLE__
// The union is already defined in sys/sem.h
#else
union semun {
    int val;
    struct semid_ds* buf;
    unsigned short int* array;
    struct seminfo* __buf;
};
#endif
 
struct sembuf Operacion;
 
ClassImp(TRestRawMemoryBufferToSignalProcess);
 
TRestRawMemoryBufferToSignalProcess::TRestRawMemoryBufferToSignalProcess() { Initialize(); }
 
TRestRawMemoryBufferToSignalProcess::TRestRawMemoryBufferToSignalProcess(const char* configFilename) {
    Initialize();
 
    LoadConfig(configFilename);
}
 
TRestRawMemoryBufferToSignalProcess::~TRestRawMemoryBufferToSignalProcess() { delete fOutputRawSignalEvent; }
 
void TRestRawMemoryBufferToSignalProcess::SemaphoreRed(int id) {
    Operacion.sem_num = 0;  // sem_id
    Operacion.sem_op = -1;
    Operacion.sem_flg = 0;
 
    semop(id, &Operacion, 1);
}
 
void TRestRawMemoryBufferToSignalProcess::SemaphoreGreen(int id) {
    Operacion.sem_num = 0;  // sem_id
    Operacion.sem_op = 1;
    Operacion.sem_flg = 0;
 
    semop(id, &Operacion, 1);
}
 
void TRestRawMemoryBufferToSignalProcess::LoadDefaultConfig() {
    SetName("sharedMemoryBufferToSignal-Default");
    SetTitle("Default config");
 
    cout << "SharedMemoryBufferToSignal metadata not found. Loading default "
            "values"
         << endl;
}
 
void TRestRawMemoryBufferToSignalProcess::LoadConfig(const string& configFilename, const string& name) {
    if (LoadConfigFromFile(configFilename, name)) {
        LoadDefaultConfig();
    }
}
 
void TRestRawMemoryBufferToSignalProcess::Initialize() {
    SetSectionName(this->ClassName());
    SetLibraryVersion(LIBRARY_VERSION);
 
    fOutputRawSignalEvent = new TRestRawSignalEvent();
 
    fReset = true;
}
 
void TRestRawMemoryBufferToSignalProcess::InitProcess() {
    cout << "TRestRawMemoryBufferToSignalProcess::InitProcess. Creating "
            "access to shared memory"
         << endl;
 
    key_t MemKey = ftok("/bin/ls", fKeyDaqInfo);
    int memId = shmget(MemKey, sizeof(daqInfo), 0777);
    if (memId == -1) {
        printf("Failed to access daqInfo resource\n");
        exit(1);
    }
 
    fShMem_daqInfo = (daqInfo*)shmat(memId, (char*)0, 0);
 
    key_t SemaphoreKey = ftok("/bin/ls", fKeySemaphore);
    fSemaphoreId = semget(SemaphoreKey, 1, 0777);
 
    if (fSemaphoreId == -1) {
        printf("Failed to access semaphore resource\n");
        exit(1);
    }
 
    if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Debug) {
        printf("Sem id : %d\n", fSemaphoreId);
 
        printf("Data ready : %d\n", fShMem_daqInfo->dataReady);
 
        printf("Number of signals : %d\n", fShMem_daqInfo->nSignals);
 
        printf("Timestamp : %lf\n", fShMem_daqInfo->timeStamp);
 
        printf("Event id : %d\n", fShMem_daqInfo->eventId);
 
        printf("Max signals :  %d\n", fShMem_daqInfo->maxSignals);
        printf("Max samples : %d\n", fShMem_daqInfo->maxSamples);
        printf("Buffer size : %d\n", fShMem_daqInfo->bufferSize);
 
        if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Extreme) GetChar();
    }
 
    int N_DATA = fShMem_daqInfo->bufferSize;
 
    MemKey = ftok("/bin/ls", fKeyBuffer);
    memId = shmget(MemKey, N_DATA * sizeof(unsigned short int), 0777 | IPC_CREAT);
    if (memId == -1) {
        printf("Failed to access buffer resource\n");
        exit(1);
    }
 
    fShMem_Buffer = (unsigned short int*)shmat(memId, (char*)0, 0);
}
 
void TRestRawMemoryBufferToSignalProcess::BeginOfEventProcess(TRestEvent* inputEvent) {
    fOutputRawSignalEvent->Initialize();
}
 
TRestEvent* TRestRawMemoryBufferToSignalProcess::ProcessEvent(TRestEvent* inputEvent) {
    while (true) {
        SemaphoreRed(fSemaphoreId);
        int dataReady = fShMem_daqInfo->dataReady;
        int maxSamples = fShMem_daqInfo->maxSamples;
        SemaphoreGreen(fSemaphoreId);
 
        // We sleep a while to do not saturate/block the daq with the semaphore.
        usleep(fTimeDelay);
 
        if (dataReady == 2) {
            SemaphoreRed(fSemaphoreId);
 
            for (unsigned int s = 0; s < fShMem_daqInfo->nSignals; s++) {
                TRestRawSignal signal;
                signal.SetSignalID(fShMem_Buffer[s * (maxSamples + 1)]);
 
                if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Debug)
                    cout << "s : " << s << " id : " << signal.GetSignalID() << endl;
 
                for (int n = 0; n < maxSamples; n++) {
                    signal.AddPoint((Short_t)fShMem_Buffer[s * (maxSamples + 1) + 1 + n]);
                }
                fOutputRawSignalEvent->AddSignal(signal);
 
                if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Extreme) {
                    signal.Print();
                    GetChar();
                }
            }
 
            if (fReset) {
                for (unsigned int n = 0; n < fShMem_daqInfo->bufferSize; n++) fShMem_Buffer[n] = 0;
            }
 
            fShMem_daqInfo->dataReady = 0;
 
            fOutputRawSignalEvent->SetID(fShMem_daqInfo->eventId);
            fOutputRawSignalEvent->SetTime(fShMem_daqInfo->timeStamp);
 
            SemaphoreGreen(fSemaphoreId);
 
            if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Info) {
                cout << "------------------------------------------" << endl;
                cout << "Event ID : " << fOutputRawSignalEvent->GetID() << endl;
                cout << "Time stamp : " << fOutputRawSignalEvent->GetTimeStamp() << endl;
                cout << "Number of Signals : " << fOutputRawSignalEvent->GetNumberOfSignals() << endl;
                cout << "------------------------------------------" << endl;
 
                if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Debug) {
                    for (Int_t n = 0; n < fOutputRawSignalEvent->GetNumberOfSignals(); n++)
                        cout << "Signal N : " << n
                             << " daq id : " << fOutputRawSignalEvent->GetSignal(n)->GetID() << endl;
                    GetChar();
                }
            }
 
            if (fOutputRawSignalEvent->GetNumberOfSignals() == 0) return nullptr;
 
            return fOutputRawSignalEvent;
        }
    }
 
    return fOutputRawSignalEvent;
}
 
void TRestRawMemoryBufferToSignalProcess::InitFromConfigFile() {
    fKeyDaqInfo = StringToInteger(GetParameter("daqInfoKey", "3"));
    fKeyBuffer = StringToInteger(GetParameter("bufferKey", "13"));
    fKeySemaphore = StringToInteger(GetParameter("semaphoreKey", "14"));
    fTimeDelay = StringToInteger(GetParameter("timeDelay", "10000"));
}