Changeset 11297 for trunk


Ignore:
Timestamp:
07/08/11 15:53:36 (13 years ago)
Author:
tbretz
Message:
Added the possibility in ConnectionFTM to compare the requested and the answered configuration; removed consistency check in Enable and SetTriggerSeq; revised teh states of ConnectionFTM and StateMachineFTM to support the configuration state; adde CONFIGURE and RESET_CONFIGURE command
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/FACT++/src/ftmctrl.cc

    r11264 r11297  
    2727class ConnectionFTM : public Connection
    2828{
     29public:
     30    enum States
     31    {
     32        // State Machine states
     33        kDisconnected = 1,
     34        kConnected,
     35        kIdle,
     36        kConfigured,  // Returned if idle and fBufStaticData==fStaticData
     37        kTakingData,
     38    };
     39
     40private:
    2941    vector<uint16_t> fBuffer;
    3042
    3143    bool fHasHeader;
    32     int fState;
     44    FTM::States fState;
    3345
    3446    bool fIsVerbose;
    … …  
    6274
    6375protected:
    64     map<uint16_t, int> fCounter;
     76    map<uint16_t, uint32_t> fCounter;
    6577
    6678    FTM::Header      fHeader;
    … …  
    6981    FTM::DynamicData fDynamicData;
    7082    FTM::Error       fError;
     83
     84    FTM::StaticData  fBufStaticData;
    7185
    7286    virtual void UpdateFirstHeader()
    … …  
    155169    }
    156170
    157     bool CheckConsistency()
     171    bool CheckConsistency(FTM::StaticData &data)
    158172    {
    159173        bool warn1 = false;
    160         if (fStaticData.IsEnabled(FTM::StaticData::kPedestal) != (fStaticData.GetSequencePed()  >0) ||
    161             fStaticData.IsEnabled(FTM::StaticData::kLPint)    != (fStaticData.GetSequenceLPint()>0) ||
    162             fStaticData.IsEnabled(FTM::StaticData::kLPext)    != (fStaticData.GetSequenceLPext()>0))
     174        if (data.IsEnabled(FTM::StaticData::kPedestal) != (data.GetSequencePed()  >0) ||
     175            data.IsEnabled(FTM::StaticData::kLPint)    != (data.GetSequenceLPint()>0) ||
     176            data.IsEnabled(FTM::StaticData::kLPext)    != (data.GetSequenceLPext()>0))
    163177        {
    164178            warn1 = true;
    165             fStaticData.Enable(FTM::StaticData::kPedestal, fStaticData.GetSequencePed()>0);
    166             fStaticData.Enable(FTM::StaticData::kLPint,    fStaticData.GetSequenceLPint()>0);
    167             fStaticData.Enable(FTM::StaticData::kLPext,    fStaticData.GetSequenceLPext()>0);
     179            data.Enable(FTM::StaticData::kPedestal, data.GetSequencePed()>0);
     180            data.Enable(FTM::StaticData::kLPint,    data.GetSequenceLPint()>0);
     181            data.Enable(FTM::StaticData::kLPext,    data.GetSequenceLPext()>0);
    168182        }
    169183
    170184        bool warn2 = false;
    171         const uint16_t ref = fStaticData[0].fPrescaling;
     185        const uint16_t ref = data[0].fPrescaling;
    172186        for (int i=1; i<40; i++)
    173187        {
    174             if (fStaticData[i].fPrescaling != ref)
     188            if (data[i].fPrescaling != ref)
    175189            {
    176190                warn2 = true;
    177                 fStaticData[i].fPrescaling = ref;
     191                data[i].fPrescaling = ref;
    178192            }
    179193        }
    … …  
    239253
    240254            // Convert FTM state into FtmCtrl state
    241             switch (fHeader.fState)
    242             {
    243             case FTM::kFtmIdle:
    244             case FTM::kFtmConfig:
    245                 fState = FTM::kIdle;
    246                 break;
    247 
    248             case FTM::kFtmCalib:
    249             case FTM::kFtmRunning:
    250                 fState = FTM::kTakingData;
    251                 break;
    252             }
    253 
    254255            if (++fCounter[FTM::kHeader]==1)
    255256                UpdateFirstHeader();
    … …  
    315316
    316317            case FTM::kStaticData:
    317                 fStaticData = fBuffer;
    318 
    319318                if (fCounter[FTM::kStaticData]==1)
    320                     if (!CheckConsistency())
     319                {
     320                    // This check is only done at startup
     321                    FTM::StaticData data = fBuffer;
     322                    if (!CheckConsistency(data))
    321323                    {
    322                         CmdSendStatDat();
     324                        CmdSendStatDat(data);
    323325                        break;
    324326                    }
    325 
     327                }
     328
     329                fStaticData = fBuffer;
    326330                UpdateStaticData();
    327331                break;
    … …  
    365369        fInTimeout.cancel();
    366370
    367         fHeader.clear();
     371        //fHeader.clear();
    368372        fHasHeader = false;
    369373        fBuffer.resize(sizeof(FTM::Header)/2);
    … …  
    374378    void ConnectionEstablished()
    375379    {
    376         fState = FTM::kConnected;
    377380        fCounter.clear();
     381        fBufStaticData.clear();
    378382
    379383        fHeader.clear();
    … …  
    483487public:
    484488    ConnectionFTM(ba::io_service& ioservice, MessageImp &imp) : Connection(ioservice, imp()),
    485         fState(0), fIsVerbose(true), fIsDynamicOut(true), fIsHexOutput(true)
     489        fIsVerbose(true), fIsDynamicOut(true), fIsHexOutput(true)
    486490    {
    487491        SetLogStream(&imp);
    … …  
    508512    }
    509513
    510     void CmdSendStatDat()
    511     {
    512         PostCmd(fStaticData.HtoN(), FTM::kCmdWrite, FTM::kCmdStaticData);
     514    void CmdSendStatDat(const FTM::StaticData &data)
     515    {
     516        fBufStaticData = data;
     517
     518        PostCmd(data.HtoN(), FTM::kCmdWrite, FTM::kCmdStaticData);
    513519
    514520        // Request the changed configuration to ensure the
    … …  
    549555        const boost::array<uint16_t, 2> data = {{ addr, val }};
    550556        PostCmd(data, FTM::kCmdWrite, FTM::kCmdRegister);
     557
     558        fBufStaticData.clear();
    551559
    552560        // Request the changed configuration to ensure the
    … …  
    614622    }
    615623*/
     624
    616625    bool LoadStaticData(string name)
    617626    {
    … …  
    636645            return false;
    637646
    638         fStaticData = data;
    639 
    640         CmdSendStatDat();
     647        CmdSendStatDat(data);
    641648
    642649        return true;
    … …  
    665672            return false;
    666673
     674        FTM::StaticData data = fStaticData;
     675
    667676        if (patch<0)
    668677        {
    669678            bool ident = true;
    670679            for (int i=0; i<160; i++)
    671                 if (fStaticData[i/4].fDAC[patch%4] != value)
     680                if (data[i/4].fDAC[patch%4] != value)
    672681                {
    673682                    ident = false;
    … …  
    679688
    680689            for (int i=0; i<160; i++)
    681                 fStaticData[i/4].fDAC[i%4] = value;
     690                data[i/4].fDAC[i%4] = value;
    682691        }
    683692        else
    684693        {
    685             if (fStaticData[patch/4].fDAC[patch%4] == value)
     694            if (data[patch/4].fDAC[patch%4] == value)
    686695                return true;
    687696
    688             fStaticData[patch/4].fDAC[patch%4] = value;
     697            data[patch/4].fDAC[patch%4] = value;
    689698        }
    690699
    691700        // Maybe move to a "COMMIT" command?
    692         CmdSendStatDat();
     701        CmdSendStatDat(data);
    693702
    694703        return true;
    … …  
    700709            return false;
    701710
     711        FTM::StaticData data = fStaticData;
     712
    702713        bool ident = true;
    703714        for (int i=0; i<40; i++)
    704             if (fStaticData[i].fPrescaling != value)
     715            if (data[i].fPrescaling != value)
    705716            {
    706717                ident = false;
    … …  
    712723
    713724        for (int i=0; i<40; i++)
    714             fStaticData[i].fPrescaling = value;
     725            data[i].fPrescaling = value;
    715726
    716727        // Maybe move to a "COMMIT" command?
    717         CmdSendStatDat();
     728        CmdSendStatDat(data);
    718729
    719730        return true;
    … …  
    725736            return false;
    726737
     738        FTM::StaticData data = fStaticData;
     739
    727740        if (board<0)
    728741        {
    729742            if (enable)
    730                 fStaticData.EnableAllFTU();
     743                data.EnableAllFTU();
    731744            else
    732                 fStaticData.DisableAllFTU();
     745                data.DisableAllFTU();
    733746        }
    734747        else
    735748        {
    736749            if (enable)
    737                 fStaticData.EnableFTU(board);
     750                data.EnableFTU(board);
    738751            else
    739                 fStaticData.DisableFTU(board);
     752                data.DisableFTU(board);
    740753
    741754        }
    742755
    743756        // Maybe move to a "COMMIT" command?
    744         CmdSendStatDat();
     757        CmdSendStatDat(data);
    745758
    746759        return true;
    … …  
    752765            return false;
    753766
    754         fStaticData.ToggleFTU(board);
     767        FTM::StaticData data = fStaticData;
     768
     769        data.ToggleFTU(board);
    755770
    756771        // Maybe move to a "COMMIT" command?
    757         CmdSendStatDat();
     772        CmdSendStatDat(data);
    758773
    759774        return true;
    … …  
    768783            return true;
    769784
     785        FTM::StaticData data = fStaticData;
     786
     787        dest = reinterpret_cast<uint16_t*>(&data) + (dest - reinterpret_cast<uint16_t*>(&fStaticData));
     788
    770789        *dest = val;
    771790
    772         CmdSendStatDat();
     791        CmdSendStatDat(data);
    773792
    774793        return true;
    … …  
    801820    void Enable(FTM::StaticData::GeneralSettings type, bool enable)
    802821    {
    803         if (fStaticData.IsEnabled(type)!=enable)
    804         {
    805             fStaticData.Enable(type, enable);
    806             CmdSendStatDat();
    807         }
     822        //if (fStaticData.IsEnabled(type)==enable)
     823        //    return;
     824
     825        FTM::StaticData data = fStaticData;
     826        data.Enable(type, enable);
     827        CmdSendStatDat(data);
    808828    }
    809829
    810830    bool SetTriggerSeq(const uint16_t d[3])
    811831    {
    812         const uint16_t oldset = fStaticData.fGeneralSettings;
    813         const uint16_t oldseq = fStaticData.fTriggerSequence;
    814 
    815832        if (d[0]>FTM::StaticData::kMaxSequence ||
    816833            d[1]>FTM::StaticData::kMaxSequence ||
    … …  
    818835            return false;
    819836
    820         fStaticData.Enable(FTM::StaticData::kPedestal, d[0]>0);
    821         fStaticData.Enable(FTM::StaticData::kLPext,    d[1]>0);
    822         fStaticData.Enable(FTM::StaticData::kLPint,    d[2]>0);
    823 
    824         fStaticData.fTriggerSequence =
     837        FTM::StaticData data = fStaticData;
     838
     839        data.Enable(FTM::StaticData::kPedestal, d[0]>0);
     840        data.Enable(FTM::StaticData::kLPext,    d[1]>0);
     841        data.Enable(FTM::StaticData::kLPint,    d[2]>0);
     842
     843        data.fTriggerSequence =
    825844            (uint16_t(d[0])<<10) | (uint16_t(d[2])<<5) | uint16_t(d[1]);
    826845
    827         if (oldseq!=fStaticData.fTriggerSequence || oldset!=fStaticData.fGeneralSettings)
    828             CmdSendStatDat();
     846        //if (fStaticData.fTriggerSeq     !=data.fTriggerSequence ||
     847        //    fStaticData.fGeneralSettings!=data.fGeneralSettings)
     848        //    CmdSendStatDat(data);
     849
     850        CmdSendStatDat(data);
    829851
    830852        return true;
    … …  
    839861            return true;
    840862
    841         fStaticData.fMultiplicityPhysics = n;
    842 
    843         CmdSendStatDat();
     863        FTM::StaticData data = fStaticData;
     864
     865        data.fMultiplicityPhysics = n;
     866
     867        CmdSendStatDat(data);
    844868
    845869        return true;
    … …  
    854878            return true;
    855879
    856         fStaticData.fWindowPhysics = win;
    857 
    858         CmdSendStatDat();
     880        FTM::StaticData data = fStaticData;
     881
     882        data.fWindowPhysics = win;
     883
     884        CmdSendStatDat(data);
    859885
    860886        return true;
    … …  
    869895            return true;
    870896
    871         fStaticData.fMultiplicityCalib = n;
    872 
    873         CmdSendStatDat();
     897        FTM::StaticData data = fStaticData;
     898
     899        data.fMultiplicityCalib = n;
     900
     901        CmdSendStatDat(data);
    874902
    875903        return true;
    … …  
    884912            return true;
    885913
    886         fStaticData.fWindowCalib = win;
    887 
    888         CmdSendStatDat();
     914        FTM::StaticData data = fStaticData;
     915
     916        data.fWindowCalib = win;
     917
     918        CmdSendStatDat(data);
    889919
    890920        return true;
    … …  
    893923    bool SetClockRegister(const uint64_t reg[])
    894924    {
     925        FTM::StaticData data = fStaticData;
     926
    895927        for (int i=0; i<8; i++)
    896928        {
    … …  
    898930                return false;
    899931
    900             fStaticData.fClockConditioner[i] = reg[i];
    901         }
    902 
    903         CmdSendStatDat();
     932            data.fClockConditioner[i] = reg[i];
     933        }
     934
     935        CmdSendStatDat(data);
    904936
    905937        return true;
    … …  
    911943            return false;
    912944
     945        FTM::StaticData data = fStaticData;
     946
    913947        if (idx==-1)
    914948            for (int i=0; i<=FTM::StaticData::kMaxPixelIdx; i++)
    915                 fStaticData.EnablePixel(i, enable);
     949                data.EnablePixel(i, enable);
    916950        else
    917             fStaticData.EnablePixel(idx, enable);
    918 
    919         CmdSendStatDat();
     951            data.EnablePixel(idx, enable);
     952
     953        CmdSendStatDat(data);
    920954
    921955        return true;
    … …  
    927961            return false;
    928962
     963        FTM::StaticData data = fStaticData;
     964
    929965        for (int i=0; i<=FTM::StaticData::kMaxPixelIdx; i++)
    930             fStaticData.EnablePixel(i, i==idx);
    931 
    932         CmdSendStatDat();
     966            data.EnablePixel(i, i==idx);
     967
     968        CmdSendStatDat(data);
    933969
    934970        return true;
    … …  
    940976            return false;
    941977
     978        FTM::StaticData data = fStaticData;
     979
    942980        for (int i=0; i<=FTM::StaticData::kMaxPixelIdx; i++)
    943             fStaticData.EnablePixel(i, i/9==idx);
    944 
    945         CmdSendStatDat();
     981            data.EnablePixel(i, i/9==idx);
     982
     983        CmdSendStatDat(data);
    946984
    947985        return true;
    … …  
    953991            return false;
    954992
    955         fStaticData.EnablePixel(idx, !fStaticData.Enabled(idx));
    956 
    957         CmdSendStatDat();
     993        FTM::StaticData data = fStaticData;
     994
     995        data.EnablePixel(idx, !fStaticData.Enabled(idx));
     996
     997        CmdSendStatDat(data);
    958998
    959999        return true;
    9601000    }
    9611001
    962     int GetState() const { return IsConnected() ? fState : (int)FTM::kDisconnected; }
     1002    States GetState() const
     1003    {
     1004        if (!IsConnected())
     1005            return kDisconnected;
     1006
     1007        switch (fHeader.fState)
     1008        {
     1009        case FTM::kFtmUndefined:
     1010            return kConnected;
     1011
     1012        case FTM::kFtmRunning:
     1013        case FTM::kFtmCalib:
     1014            return kTakingData;
     1015
     1016        case FTM::kFtmIdle:
     1017        case FTM::kFtmConfig:
     1018            return fStaticData == fBufStaticData ? kConfigured : kIdle;
     1019        }
     1020
     1021        throw runtime_error("ConnectionFTM::GetState - Impossible code reached.");
     1022    }
     1023
     1024    int GetCounter(FTM::Types type) { return fCounter[type]; }
     1025
     1026    const FTM::StaticData &GetStaticData() const { return fStaticData; }
    9631027};
    9641028
    … …  
    10841148    S fFTM;
    10851149
    1086     enum states_t
    1087     {
    1088         kStateDisconnected = FTM::kDisconnected,
    1089         kStateConnected    = FTM::kConnected,
    1090         kStateIdle         = FTM::kIdle,
    1091         kStateTakingData   = FTM::kTakingData,
    1092 
    1093         kCmdTest
    1094     };
    1095 
    10961150    bool CheckEventSize(size_t has, const char *name, size_t size)
    10971151    {
    … …  
    15501604        switch (evt.GetTargetState())
    15511605        {
    1552         case kStateDisconnected:
    1553         case kStateConnected:
     1606        case kDisconnected:
     1607        case kConnected:
    15541608        }
    15551609
    15561610        return T::kSM_FatalError;
    15571611    }*/
     1612
     1613    int64_t fCounterReg;
     1614    int64_t fCounterStat;
     1615
     1616    typedef map<string, FTM::StaticData> Configs;
     1617    Configs fConfigs;
     1618    Configs::const_iterator fTargetConfig;
     1619
     1620    int ConfigureFTM(const EventImp &evt)
     1621    {
     1622        const string name = evt.GetText();
     1623
     1624        fTargetConfig = fConfigs.find(name);
     1625        if (fTargetConfig==fConfigs.end())
     1626        {
     1627            T::Error("Configuration '"+name+"' not found.");
     1628            return T::GetCurrentState();
     1629        }
     1630
     1631        T::Message("Starting configuration for '"+name+"'");
     1632
     1633        fCounterReg = fFTM.GetCounter(FTM::kRegister);
     1634        fFTM.CmdStopRun();
     1635
     1636        return FTM::kConfiguring1;
     1637    }
     1638
     1639    int ResetConfig(const EventImp &)
     1640    {
     1641        return fFTM.GetState();
     1642    }
    15581643
    15591644    int Execute()
    … …  
    15661651        poll_one();
    15671652
    1568         return fFTM.GetState();
     1653        // If FTM is neither in data taking nor idle,
     1654        // leave configuration state
     1655        switch (fFTM.GetState())
     1656        {
     1657        case ConnectionFTM::kDisconnected: return FTM::kDisconnected;
     1658        case ConnectionFTM::kConnected:    return FTM::kConnected;
     1659        case ConnectionFTM::kTakingData:   return FTM::kTakingData;
     1660        default:
     1661            break;
     1662        }
     1663
     1664        switch (T::GetCurrentState())
     1665        {
     1666        case FTM::kConfiguring1:
     1667            // If FTM has received an anwer to the stop_run command
     1668            // the counter for the registers has been increased
     1669            if (fFTM.GetCounter(FTM::kRegister)<=fCounterReg)
     1670                break;
     1671
     1672            // If now the state is not idle as expected this means we had
     1673            // an error (maybe old events waiting in the queue)
     1674            if (fFTM.GetState()!=ConnectionFTM::kIdle &&
     1675                fFTM.GetState()!=ConnectionFTM::kConfigured)
     1676                return FTM::kConfigError1;
     1677
     1678            fCounterStat = fFTM.GetCounter(FTM::kStaticData);
     1679
     1680            T::Message("Trigger successfully disabled... sending new configuration.");
     1681
     1682            fFTM.CmdSendStatDat(fTargetConfig->second);
     1683
     1684            // Next state is: wait for the answer to our configuration
     1685            return FTM::kConfiguring2;
     1686
     1687        case FTM::kConfiguring2:
     1688        case FTM::kConfigured:
     1689            // If FTM has received an anwer to the stop_run command
     1690            // the counter for the registers has been increased
     1691            if (fFTM.GetCounter(FTM::kStaticData)<=fCounterStat)
     1692                break;
     1693
     1694            // If now the configuration is not what we expected
     1695            // we had an error (maybe old events waiting in the queue?)
     1696            // ======================
     1697            if (fFTM.GetState()!=ConnectionFTM::kConfigured)
     1698                return FTM::kConfigError2;
     1699            // ======================
     1700
     1701            // Check configuration again when a new static data block
     1702            // will be received
     1703            fCounterStat = fFTM.GetCounter(FTM::kStaticData);
     1704
     1705            T::Message("Sending new configuration was successfull.");
     1706
     1707            // Next state is: wait for the answer to our configuration
     1708            return FTM::kConfigured;
     1709
     1710        default:
     1711            switch (fFTM.GetState())
     1712            {
     1713            case ConnectionFTM::kIdle:         return FTM::kIdle;
     1714            case ConnectionFTM::kConfigured:   return FTM::kIdle;
     1715            default:
     1716                throw runtime_error("StateMachienFTM - Execute() - Inavlid state.");
     1717            }
     1718        }
     1719
     1720        return T::GetCurrentState();
    15691721    }
    15701722
    … …  
    15821734
    15831735        // State names
    1584         AddStateName(kStateDisconnected, "Disconnected",
    1585                      "FTM board not connected via ethernet.");
    1586 
    1587         AddStateName(kStateConnected, "Connected",
    1588                      "Ethernet connection to FTM established (no state received yet).");
    1589 
    1590         AddStateName(kStateIdle, "Idle",
    1591                      "Ethernet connection to FTM established, FTM in idle state.");
    1592 
    1593         AddStateName(kStateTakingData, "TakingData",
    1594                      "Ethernet connection to FTM established, FTM is in taking data state.");
     1736        T::AddStateName(FTM::kDisconnected, "Disconnected",
     1737                        "FTM board not connected via ethernet.");
     1738
     1739        T::AddStateName(FTM::kConnected, "Connected",
     1740                        "Ethernet connection to FTM established (no state received yet).");
     1741
     1742        T::AddStateName(FTM::kIdle, "Idle",
     1743                        "Ethernet connection to FTM established, FTM in idle state.");
     1744
     1745        T::AddStateName(FTM::kConfiguring1, "Configuring1",
     1746                        "Command to diable run sent... waiting for response.");
     1747        T::AddStateName(FTM::kConfiguring2, "Configuring2",
     1748                        "New configuration sent... waiting for response.");
     1749        T::AddStateName(FTM::kConfigured,   "Configured",
     1750                        "Received answer identical with target configuration.");
     1751
     1752        T::AddStateName(FTM::kTakingData, "TakingData",
     1753                        "Ethernet connection to FTM established, FTM is in taking data state.");
     1754
     1755        T::AddStateName(FTM::kConfigError1, "ErrorInConfig1", "");
     1756        T::AddStateName(FTM::kConfigError2, "ErrorInConfig2", "");
    15951757
    15961758        // FTM Commands
    1597         AddEvent("TOGGLE_LED", kStateIdle)
     1759        T::AddEvent("TOGGLE_LED", FTM::kIdle)
    15981760            (Wrapper(boost::bind(&ConnectionFTM::CmdToggleLed, &fFTM)))
    15991761            ("toggle led");
    16001762
    1601         AddEvent("PING", kStateIdle)
     1763        T::AddEvent("PING", FTM::kIdle)
    16021764            (Wrapper(boost::bind(&ConnectionFTM::CmdPing, &fFTM)))
    16031765            ("send ping");
    16041766
    1605         AddEvent("REQUEST_DYNAMIC_DATA", kStateIdle)
     1767        T::AddEvent("REQUEST_DYNAMIC_DATA", FTM::kIdle)
    16061768            (Wrapper(boost::bind(&ConnectionFTM::CmdReqDynDat, &fFTM)))
    16071769            ("request transmission of dynamic data block");
    16081770
    1609         AddEvent("REQUEST_STATIC_DATA", kStateIdle)
     1771        T::AddEvent("REQUEST_STATIC_DATA", FTM::kIdle)
    16101772            (Wrapper(boost::bind(&ConnectionFTM::CmdReqStatDat, &fFTM)))
    16111773            ("request transmission of static data from FTM to memory");
    16121774
    1613         AddEvent("GET_REGISTER", "I", kStateIdle)
     1775        T::AddEvent("GET_REGISTER", "I", FTM::kIdle)
    16141776            (boost::bind(&StateMachineFTM::GetRegister, this, _1))
    16151777            ("read register from address addr"
    16161778            "|addr[short]:Address of register");
    16171779
    1618         AddEvent("SET_REGISTER", "I:2", kStateIdle)
     1780        T::AddEvent("SET_REGISTER", "I:2", FTM::kIdle)
    16191781            (boost::bind(&StateMachineFTM::SetRegister, this, _1))
    16201782            ("set register to value"
    … …  
    16221784            "|val[short]:Value to be set");
    16231785
    1624         AddEvent("START_RUN", kStateIdle)
     1786        T::AddEvent("START_RUN", FTM::kIdle, FTM::kConfigured)
    16251787            (Wrapper(boost::bind(&ConnectionFTM::CmdStartRun, &fFTM)))
    16261788            ("start a run (start distributing triggers)");
    16271789
    1628         AddEvent("STOP_RUN", kStateTakingData)
     1790        T::AddEvent("STOP_RUN", FTM::kTakingData)
    16291791            (Wrapper(boost::bind(&ConnectionFTM::CmdStopRun, &fFTM)))
    16301792            ("stop a run (stop distributing triggers)");
    16311793
    1632         AddEvent("TAKE_N_EVENTS", "I", kStateIdle)
     1794        T::AddEvent("TAKE_N_EVENTS", "I", FTM::kIdle)
    16331795            (boost::bind(&StateMachineFTM::TakeNevents, this, _1))
    16341796            ("take n events (distribute n triggers)|number[int]:Number of events to be taken");
    16351797
    1636         AddEvent("DISABLE_REPORTS", "B", kStateIdle)
     1798        T::AddEvent("DISABLE_REPORTS", "B", FTM::kIdle)
    16371799            (boost::bind(&StateMachineFTM::DisableReports, this, _1))
    16381800            ("disable sending rate reports"
    16391801             "|status[bool]:disable or enable that the FTM sends rate reports (yes/no)");
    16401802
    1641         AddEvent("SET_THRESHOLD", "I:2", kStateIdle)
     1803        T::AddEvent("SET_THRESHOLD", "I:2", FTM::kIdle)
    16421804            (boost::bind(&StateMachineFTM::SetThreshold, this, _1))
    16431805            ("Set the comparator threshold"
    … …  
    16451807             "|Threshold[counts]:Threshold to be set in binary counts");
    16461808
    1647         AddEvent("SET_PRESCALING", "I:1", kStateIdle)
     1809        T::AddEvent("SET_PRESCALING", "I:1", FTM::kIdle)
    16481810            (boost::bind(&StateMachineFTM::SetPrescaling, this, _1))
    16491811            (""
    16501812             "|[]:");
    16511813
    1652         AddEvent("ENABLE_FTU", "I:1;B:1", kStateIdle)
     1814        T::AddEvent("ENABLE_FTU", "I:1;B:1", FTM::kIdle)
    16531815            (boost::bind(&StateMachineFTM::EnableFTU, this, _1))
    16541816            ("Enable or disable FTU"
    … …  
    16561818             "|Enable[bool]:Whether FTU should be enabled or disabled (yes/no)");
    16571819
    1658         AddEvent("DISABLE_PIXEL", "S:1", kStateIdle)
     1820        T::AddEvent("DISABLE_PIXEL", "S:1", FTM::kIdle)
    16591821            (boost::bind(&StateMachineFTM::EnablePixel, this, _1, false))
    16601822            ("(-1 or all)");
    16611823
    1662         AddEvent("ENABLE_PIXEL", "S:1", kStateIdle)
     1824        T::AddEvent("ENABLE_PIXEL", "S:1", FTM::kIdle)
    16631825            (boost::bind(&StateMachineFTM::EnablePixel, this, _1, true))
    16641826            ("(-1 or all)");
    16651827
    1666         AddEvent("DISABLE_ALL_PIXELS_EXCEPT", "S:1", kStateIdle)
     1828        T::AddEvent("DISABLE_ALL_PIXELS_EXCEPT", "S:1", FTM::kIdle)
    16671829            (boost::bind(&StateMachineFTM::DisableAllPixelsExcept, this, _1))
    16681830            ("");
    16691831
    1670         AddEvent("DISABLE_ALL_PATCHES_EXCEPT", "S:1", kStateIdle)
     1832        T::AddEvent("DISABLE_ALL_PATCHES_EXCEPT", "S:1", FTM::kIdle)
    16711833            (boost::bind(&StateMachineFTM::DisableAllPatchesExcept, this, _1))
    16721834            ("");
    16731835
    1674         AddEvent("TOGGLE_PIXEL", "S:1", kStateIdle)
     1836        T::AddEvent("TOGGLE_PIXEL", "S:1", FTM::kIdle)
    16751837            (boost::bind(&StateMachineFTM::TogglePixel, this, _1))
    16761838            ("");
    16771839
    1678         AddEvent("TOGGLE_FTU", "I:1", kStateIdle)
     1840        T::AddEvent("TOGGLE_FTU", "I:1", FTM::kIdle)
    16791841            (boost::bind(&StateMachineFTM::ToggleFTU, this, _1))
    16801842            ("Toggle status of FTU (this is mainly meant to be used in the GUI)"
    16811843             "|Board[idx]:Index of the board (0-39)");
    16821844
    1683         AddEvent("SET_TRIGGER_INTERVAL", "I:1", kStateIdle)
     1845        T::AddEvent("SET_TRIGGER_INTERVAL", "I:1", FTM::kIdle)
    16841846            (boost::bind(&StateMachineFTM::SetTriggerInterval, this, _1))
    16851847            ("Sets the trigger interval which is the distance between two consecutive artificial triggers."
    16861848             "|interval[int]:The applied trigger interval is: interval*4ns+8ns");
    16871849
    1688         AddEvent("SET_TRIGGER_DELAY", "I:1", kStateIdle)
     1850        T::AddEvent("SET_TRIGGER_DELAY", "I:1", FTM::kIdle)
    16891851            (boost::bind(&StateMachineFTM::SetTriggerDelay, this, _1))
    16901852            (""
    16911853             "|delay[int]:The applied trigger delay is: delay*4ns+8ns");
    16921854
    1693         AddEvent("SET_TIME_MARKER_DELAY", "I:1", kStateIdle)
     1855        T::AddEvent("SET_TIME_MARKER_DELAY", "I:1", FTM::kIdle)
    16941856            (boost::bind(&StateMachineFTM::SetTimeMarkerDelay, this, _1))
    16951857            (""
    16961858            "|delay[int]:The applied time marker delay is: delay*4ns+8ns");
    16971859
    1698         AddEvent("SET_DEAD_TIME", "I:1", kStateIdle)
     1860        T::AddEvent("SET_DEAD_TIME", "I:1", FTM::kIdle)
    16991861            (boost::bind(&StateMachineFTM::SetDeadTime, this, _1))
    17001862            (""
    17011863            "|dead_time[int]:The applied dead time is: dead_time*4ns+8ns");
    17021864
    1703         AddEvent("ENABLE_TRIGGER", "B:1", kStateIdle)
     1865        T::AddEvent("ENABLE_TRIGGER", "B:1", FTM::kIdle)
    17041866            (boost::bind(&StateMachineFTM::Enable, this, _1, FTM::StaticData::kTrigger))
    17051867            ("Switch on the physics trigger"
    … …  
    17071869
    17081870        // FIXME: Switch on/off depending on sequence
    1709         AddEvent("ENABLE_EXT1", "B:1", kStateIdle)
     1871        T::AddEvent("ENABLE_EXT1", "B:1", FTM::kIdle)
    17101872            (boost::bind(&StateMachineFTM::Enable, this, _1, FTM::StaticData::kExt1))
    17111873            ("Switch on the triggers through the first external line"
    … …  
    17131875
    17141876        // FIXME: Switch on/off depending on sequence
    1715         AddEvent("ENABLE_EXT2", "B:1", kStateIdle)
     1877        T::AddEvent("ENABLE_EXT2", "B:1", FTM::kIdle)
    17161878            (boost::bind(&StateMachineFTM::Enable, this, _1, FTM::StaticData::kExt2))
    17171879            ("Switch on the triggers through the second external line"
    17181880             "|Enable[bool]:Enable ext2 trigger (yes/no)");
    17191881
    1720         AddEvent("ENABLE_VETO", "B:1", kStateIdle)
     1882        T::AddEvent("ENABLE_VETO", "B:1", FTM::kIdle)
    17211883            (boost::bind(&StateMachineFTM::Enable, this, _1, FTM::StaticData::kVeto))
    17221884            ("Enable veto line"
    17231885             "|Enable[bool]:Enable veto (yes/no)");
    17241886
    1725         AddEvent("ENABLE_CLOCK_CONDITIONER", "B:1", kStateIdle)
     1887        T::AddEvent("ENABLE_CLOCK_CONDITIONER", "B:1", FTM::kIdle)
    17261888            (boost::bind(&StateMachineFTM::Enable, this, _1, FTM::StaticData::kClockConditioner))
    17271889            ("Enable clock conidtioner output in favor of time marker output"
    17281890             "|Enable[bool]:Enable clock conditioner (yes/no)");
    17291891
    1730         AddEvent("SET_TRIGGER_SEQUENCE", "S:3", kStateIdle)
     1892        T::AddEvent("SET_TRIGGER_SEQUENCE", "S:3", FTM::kIdle)
    17311893            (boost::bind(&StateMachineFTM::SetTriggerSeq, this, _1))
    17321894            ("Setup the sequence of artificial triggers produced by the FTM"
    … …  
    17351897             "|LPint[short]:number of triggers of the internal light pulser");
    17361898
    1737         AddEvent("SET_TRIGGER_MULTIPLICITY", "S:1", kStateIdle)
     1899        T::AddEvent("SET_TRIGGER_MULTIPLICITY", "S:1", FTM::kIdle)
    17381900            (boost::bind(&StateMachineFTM::SetTriggerMultiplicity, this, _1))
    17391901            ("Setup the Multiplicity condition for physcis triggers"
    17401902             "|N[int]:Number of requirered coincident triggers from sum-patches (1-40)");
    17411903
    1742         AddEvent("SET_TRIGGER_WINDOW", "S:1", kStateIdle)
     1904        T::AddEvent("SET_TRIGGER_WINDOW", "S:1", FTM::kIdle)
    17431905            (boost::bind(&StateMachineFTM::SetTriggerWindow, this, _1))
    17441906            ("");
    17451907
    1746         AddEvent("SET_CALIBRATION_MULTIPLICITY", "S:1", kStateIdle)
     1908        T::AddEvent("SET_CALIBRATION_MULTIPLICITY", "S:1", FTM::kIdle)
    17471909            (boost::bind(&StateMachineFTM::SetCalibMultiplicity, this, _1))
    17481910            ("Setup the Multiplicity condition for artificial (calibration) triggers"
    17491911             "|N[int]:Number of requirered coincident triggers from sum-patches (1-40)");
    17501912
    1751         AddEvent("SET_CALIBRATION_WINDOW", "S:1", kStateIdle)
     1913        T::AddEvent("SET_CALIBRATION_WINDOW", "S:1", FTM::kIdle)
    17521914            (boost::bind(&StateMachineFTM::SetCalibWindow, this, _1))
    17531915            ("");
    17541916
    1755         AddEvent("SET_CLOCK_FREQUENCY", "I:1", kStateIdle)
     1917        T::AddEvent("SET_CLOCK_FREQUENCY", "I:1", FTM::kIdle)
    17561918            (boost::bind(&StateMachineFTM::SetClockFrequency, this, _1))
    17571919            ("");
    17581920
    1759         AddEvent("SET_CLOCK_REGISTER", "X:8", kStateIdle)
     1921        T::AddEvent("SET_CLOCK_REGISTER", "X:8", FTM::kIdle)
    17601922            (boost::bind(&StateMachineFTM::SetClockRegister, this, _1))
    17611923            ("");
    17621924
    1763 
    1764 
    1765         AddEvent("RESET_CRATE", "S:1", kStateIdle)
     1925        T::AddEvent("CONFIGURE", "C", FTM::kIdle, FTM::kTakingData)
     1926            (boost::bind(&StateMachineFTM::ConfigureFTM, this, _1))
     1927            ("");
     1928
     1929        T::AddEvent("RESET_CONFIGURE", FTM::kConfiguring1, FTM::kConfiguring2, FTM::kConfigured, FTM::kConfigError1, FTM::kConfigError2)
     1930            (boost::bind(&StateMachineFTM::ResetConfig, this, _1))
     1931            ("");
     1932
     1933
     1934
     1935        T::AddEvent("RESET_CRATE", "S:1", FTM::kIdle)
    17661936            (boost::bind(&StateMachineFTM::ResetCrate, this, _1))
    17671937            ("Reset one of the crates 0-3"
    17681938             "|crate[short]:Crate number to be reseted (0-3)");
    17691939
    1770         AddEvent("RESET_CAMERA", kStateIdle)
     1940        T::AddEvent("RESET_CAMERA", FTM::kIdle)
    17711941            (Wrapper(boost::bind(&ConnectionFTM::CmdResetCamera, &fFTM)))
    17721942            ("Reset all crates. The commands are sent in the order 0,1,2,3");
    … …  
    17741944
    17751945        // Load/save static data block
    1776         T::AddEvent("SAVE", "C", kStateIdle)
     1946        T::AddEvent("SAVE", "C", FTM::kIdle)
    17771947            (boost::bind(&StateMachineFTM::SaveStaticData, this, _1))
    17781948            ("Saves the static data (FTM configuration) from memory to a file"
    17791949             "|filename[string]:Filename (can include a path), .bin is automatically added");
    17801950
    1781         T::AddEvent("LOAD", "C", kStateIdle)
     1951        T::AddEvent("LOAD", "C", FTM::kIdle)
    17821952            (boost::bind(&StateMachineFTM::LoadStaticData, this, _1))
    17831953            ("Loads the static data (FTM configuration) from a file into memory and sends it to the FTM"
    … …  
    18041974
    18051975        // Conenction commands
    1806         AddEvent("DISCONNECT", kStateConnected, kStateIdle)
     1976        T::AddEvent("DISCONNECT", FTM::kConnected, FTM::kIdle)
    18071977            (boost::bind(&StateMachineFTM::Disconnect, this))
    18081978            ("disconnect from ethernet");
    18091979
    1810         AddEvent("RECONNECT", "O", kStateDisconnected, kStateConnected, kStateIdle)
     1980        T::AddEvent("RECONNECT", "O", FTM::kDisconnected, FTM::kConnected, FTM::kIdle, FTM::kConfigured)
    18111981            (boost::bind(&StateMachineFTM::Reconnect, this, _1))
    18121982            ("(Re)connect ethernet connection to FTM, a new address can be given"
    … …  
    18302000
    18312001//        fFTM.SetDefaultSetup(conf.Get<string>("default-setup"));
     2002
     2003        fConfigs["test"] = FTM::StaticData();
     2004
    18322005
    18332006        return -1;
Note: See TracChangeset for help on using the changeset viewer.