pixeltrigger.cpp

Go to the documentation of this file.

//============================================================================
// Name        : pixeltrigger.cpp
// Author      : Gianluca and Cesar
// Version     :
// Copyright   : GNU License is good for you
// Description : Hello World in C++, Ansi-style
//============================================================================


#include <iostream>
#include <fstream>
#include <sstream>
#include <log4cpp/BasicConfigurator.hh>
#include <log4cpp/Category.hh>
#include <log4cpp/FileAppender.hh>
#include <log4cpp/PatternLayout.hh>
#include <sstream>
#include <dis.hxx>                      //dim server stuff 

#include "pit_def.h"
#include "pit_driver.h"
#include "pit_comm.h"
#include "pit_configuration.h"
#include "pit_keyboard.h"
#include "DimAppender.h"

using namespace std;
// Compares two arrays of 32 bit registers, useful for the stress testing
int compareArrays(UInt32 *a1, UInt32 *a2, int size);

// function to stress test a memory block in the hardware 
void testReadMemBlock(pit_driver * pit, UInt19 startAdress = 0x1800000, UInt19 numberOfWords= 0x1000, UInt19 blockSize = 1024);
// it reads 0x1000 words from the hardware, but word by word and not using the read block functionality 
void testReadWord(pit_driver * pit, UInt19 startAdress = 0x1800000, UInt19 numberOfWords= 0x1000);

void simulate_values(pit_driver *pit);

int main(void){



        // Logger instantiation, using log4cpp library
        // create appender to log file
        log4cpp::Appender* fileApp = new log4cpp::FileAppender("FileAppender","./pit.log");
        // creates a dim appender class
        log4cpp::Appender* dimApp = new log4cpp::DimAppender("DimAppender", DIM_LOG_NAME);
        // create a PatternLayout
        log4cpp::PatternLayout* layout = new log4cpp::PatternLayout();

        // set the format
        layout->setConversionPattern("%d{%Y %b %d %a %H:%M:%S,%l} %p %c %x: %m%n");

        fileApp->setLayout(layout);
        dimApp->setLayout(layout);

        //log4cpp::BasicConfigurator::configure();
        log4cpp::Category& logger = log4cpp::Category::getInstance("pitLog");


        //log4cpp::Appender* dimApp2 = new log4cpp::DimAppender("dummylog", "dummyService");
        //log4cpp::Appender* dimApp3 = new log4cpp::DimAppender("DimAppender3", "yetAnotherLogService");

                
        logger.setAdditivity(true);

                // there is some kind of problem while using the fileAppender 
                // if there are more than one appender in the category
                // so here we are not passing the 
        logger.addAppender(*fileApp);
        logger.addAppender(dimApp);                                     // adds the dim appender
        //logger.addAppender(dimApp3);                          // adds the dim appender
         
        logger.setPriority(log4cpp::Priority::DEBUG); //here the logginess can be changed
        dimApp->setThreshold(log4cpp::Priority::DEBUG);// here we can set the priority of the dim logging
        

        //Get the instance of the configuration handler
        pit_configuration& configurator = pit_configuration::getInstance();

        // starts here DIM server
        DimServer::start("pit_feDimServer");

        configurator.openCoordinateTableFile("tableFile.txt");


        //Create hierarchy of driver objects
        pit_driver *pit = new pit_driver();
        //configurator.dumpCoordinateTableToFile("defaultCoordinates.txt");
        //configurator.dumpRequiredLinksToFile("defaultRequiredLinks.txt");



        //*******************************************************************************

        const int cmdLineMax=256;
        char command[cmdLineMax];                       // command line buffer maximun number of chars 256



        // main execution loop
        while(1){

                // if there is any command line executes also the command 
                if ( pit_keyboard::kbhit() ){

                        cin.get(command, cmdLineMax, '\n');
                        if (strcmp(command, "quit")==0)break;
                        pit->executeCommand(command);   // parses and executes the command line
                        cin.ignore();                                   // this ignore will make it ignore the last '\n' that it is still in the buffer
                        // took some time but found it out :), now it works!!!
                }
                // checks if there are dim commands and executes 
                pit->checkDimCommands();
                // sleeps for 300 milliseconds
                sleepMilli(300);
        }

        //*******************************************************************************


        delete pit;

                        // cleans all things conencted to the log4cpp
        log4cpp::Appender::closeAll();
        log4cpp::Category::shutdown();
        

        // there is some kind of bug in the fileAppender class so I cannot delete it or even close the file
        //fileApp.close();
        //delete fileApp;
        return(0);

}/* end main */



int compareArrays(UInt32 *a1, UInt32 *a2, int size){
        int out = 0;
        for (int index = 0 ; index < size ; index ++){

                if (a1[index]!= a2[index]){
                        cout<< "\t error " << index << " : " << a1[index]<< "\t,"<< a2[index]<< endl;
                        out ++;
                }
        }

        return out;
}



void testReadWord(pit_driver * pit, UInt19 startAdress, UInt19 numberOfWords){

        UInt32 inputData ;
        UInt32 outputData;

        int errors = 0;
        for (UInt32 address = 0 ; address <  numberOfWords ; address ++){

                outputData = address;
                pit->commFEE->PITWriteBlock( startAdress + address, 1, &outputData);
                pit->commFEE->PITReadBlock(  startAdress + address, 1, &inputData);

                if (inputData != outputData){
                        cout << "error address "<< hex << address <<" : " ;
                        cout << hex << outputData<<" , "<< inputData <<endl;
                        errors ++;
                }


        }
        cout << "test read word: "<< dec << errors << " errors found"<<endl;

}

void testReadMemBlock(pit_driver * pit, UInt19 startAdress, UInt19 numberOfWords, UInt19 blockSize){

        UInt32 inputData[blockSize] ;
        UInt32 outputData[blockSize];

        // initializes the block to read, all blocks will write the same information
        // 0, 1, 2 .. size of the block
        for (unsigned int index = 0 ; index < blockSize ; index ++){
                outputData[index]= index;
        }

        int blockErrors = 0;
        int wordErrors=0;

        for (UInt32 address = 0 ; address <  numberOfWords ; address +=blockSize){

                pit->commFEE->PITWriteBlock( startAdress + address, blockSize, outputData);
                pit->commFEE->PITReadBlock(  startAdress + address, blockSize, inputData);
                //cout << "block " << hex << startAdress + address << " size "<<dec<<blockSize<< " :\n";

                int error=compareArrays(outputData, inputData, blockSize);
                if (error){
                        blockErrors ++;
                        wordErrors+=error;
                }

        }

        cout << "test read block errors:  "<< dec << blockErrors << " errors found"<<endl;
        cout << "test read word errors:  "<< dec << wordErrors << " errors found"<<endl;
}

void simulate_values(pit_driver *pit){
        int board = 0;
        UInt28 baseAddress = OPTIN_BOARDS_BASE_ADDRESS + board*OPTIN_BOARDS_OFFSET;

        for (int link = 0 ; link < NUMBER_OPTICAL_LINKS ; link ++){
                UInt28 addressSetting = baseAddress  + LINK_SETTING_OFFSET +link;
                UInt28 addressStatus=  baseAddress + LINK_STATUS_OFFSET + link;
                pit->commFEE->PITWriteWord(addressStatus, 0xffffffff);
                pit->commFEE->PITWriteWord(addressSetting, 0x0);
        }

}

---