ll2.cpp

Go to the documentation of this file.

/* ------------------------------------------------------------------------- */
/* file ll2.cpp                                                                 */
/* ------------------------------------------------------------------------- */
/*   Copyright (C) 2011 Peter Milne, D-TACQ Solutions Ltd
 *                      <Peter dot Milne at D hyphen TACQ dot com>
 *  Created on: Sep 25, 2011
 *      Author: pgm

    http://www.d-tacq.com

    This program is free software; you can redistribute it and/or modify
    it under the terms of Version 2 of the GNU General Public License
    as published by the Free Software Foundation;

    This program 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 received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
/* ------------------------------------------------------------------------- */

/** @file ll2.cpp API implementation for LOWLATENCY2.
 *
 */


#include "local.h"
#include <assert.h>
#include <popt.h>
#include <stdlib.h>
#include <map>
#include <iostream>
#include <fstream>
#include <string>
using namespace std;


#include "acq32ioctl.h"
#include "acq32busprot.h"

#include "llif.h"
#include "llprotocol.h"
#include "ll2.h"
#include "llcontrol.h"
#include "llcontrol-core.h"

#include "xmlParser.h"

#define VERID   "ll2 B1003"

#define FOREACH(ii, vec) \
                for (int lim = vec.size(), ii = 0; ii != lim; ++ii)


int monitor = 0;


static const char* IO(enum IO io)
{
        switch(io){
        case AI: return "AI";
        case AO: return "AO";
        case DI: return "DI";
        case DO: return "DO";
        case ST: return "ST";
        default:
                        return "??";
        }
}

static std::map<int, ACQ_Card*> __slots;

void ACQ_Card::registerCard(int slot)
{
        if (__slots[slot] != 0){
                fprintf(stderr, "ERROR: card already exists at slot:%d\n", slot);
                exit(-1);
        }
        __slots[slot] = this;
}

ACQ_Card* ACQ_Card::getCard(int slot)
{
        return __slots[slot];
}

int ACQ196::getAI(short* ai_values)
{
        u32* adcs = getVaddr(card->buf, LLCV2_AI_HSBT);
        memcpy(ai_values, adcs, ai_count*AI_SIZE);
        return ai_count;
}
int ACQ196::putAO(const short* ao_values)
{
        u32* dacs = getVaddr(card->buf, LLCV2_AO_HSBS);

        memcpy(dacs, ao_values, ao_count*AO_SIZE);
        return ao_count;
}
int ACQ196::putDO(const unsigned *do_values)
{
        u32* va_base = getVaddr(card->buf, LLCV2_AO_HSBS);
        va_base[LLC_SYNC2V_DO] = *do_values;
        return do_count;
}
int ACQ196::getDI(unsigned *di_values)
{
        u32* stats = getVaddr(card->buf, card->sync_2v_offset_status_hsbt);
        *di_values = stats[LLC_SYNC2V_IN_DI32];
        return di_count;
}

void ACQ196::toggle_wd(void)
{
        u32* va_base = getVaddr(card->buf, LLCV2_AO_HSBS);
        unsigned wd_bit = va_base[LLC_SYNC2V_WD];
        va_base[LLC_SYNC2V_WD] = wd_bit ^ LLC_SYNC2V_WD_BIT;
}

#define STATUS_COUNT    16
#define STATUS_LEN              (STATUS_COUNT*sizeof(u32))

int ACQ196::getStatus(unsigned *status_values)
{
        u32* stats = getVaddr(card->buf, card->sync_2v_offset_status_hsbt);
        memcpy(status_values, stats, STATUS_LEN);
        return STATUS_COUNT;
}


int ACQ196::getStatus_count(void) const { return STATUS_COUNT; }

#define AO32_AO_COUNT   32
#define AO32_AO_SIZE    (AO32_AO_COUNT*sizeof(short))
#define AO32_AO_PAIRS   (AO32_AO_COUNT/2)
#define AO32_DO_SIZE    8

int AO32::putAO(const short* ao_values)
{
        int offset_b = INDEX_OF_LLC_SYNC2V_AO32(seq)*sizeof(u32);
        u32* dacs = getVaddr(master->card->buf, LLCV2_AO_HSBS + offset_b);
        memcpy(dacs, ao_values, AO32_AO_SIZE);
        return AO32_AO_SIZE;
}
int AO32::putDO(const unsigned *do_values)
{
        int offset_b = INDEX_OF_LLC_SYNC2V_AO32(seq)*sizeof(u32);
        u32* dacs = getVaddr(master->card->buf, LLCV2_AO_HSBS+offset_b);

        memcpy(dacs+AO32_AO_PAIRS, do_values, AO32_DO_SIZE);
        return AO32_DO_SIZE;
}


struct ClientBufCursor {
        ACQ_Card& card;                 /**< the card. */
        int client_offset;              /**< offset in client buffer. */

        ClientBufCursor(ACQ_Card& _card, int _client_offset) :
                card(_card), client_offset(_client_offset)
        {}
        virtual ~ClientBufCursor()
        {}
};

typedef vector<ClientBufCursor*>::iterator CBI;

XMLSTR stuff;

/** concrete implementation, private to this module. */
class LL_ControlSystemI : public  LL_ControlSystem {

        vector<ACQ_Card*> acq196;
        vector<ACQ_Card*> ao32;
        vector<ClientBufCursor*> AO_cursors;
        vector<ClientBufCursor*> AI_cursors;
        vector<ClientBufCursor*> DO_cursors;
        vector<ClientBufCursor*> DI_cursors;
        vector<ClientBufCursor*> ST_cursors;

        TestDescription *td;

        TimingStats tstats[MAXCARDS];
        u32 cmd;
        bool is_armed;
        bool finalize_done;

        void finalize(vector <ACQ_Card*>& cards, int offsets[4]);
        void finalize();
        void prime_ao(const short* ao_values);
        void prime_do(const unsigned* do_values);
        void gather_ai(short* ai_values);
        void gather_di(unsigned* di_values);
        void gather_status(unsigned *status);
        void toggle_wd(void);

        static void printClientOffset(const char *id, int offset);

        void printClientOffsets(ACQ_Card* card);

        static int lookupOffset(vector<ClientBufCursor*> cursors, const ACQ_Card* card);

        void simple_print();
        void print_xml(enum IO io, int len, int offset = 0);
        void print_xml(LL_ControlSystemI* sys, const char* typ);
        void print_xml(ACQ_Card* acq, enum IO io);
        void print_xml(ACQ_Card* card, const char* typ);
        void print_xml();

        static void setDefaults(TestDescription *td);

public:
        LL_ControlSystemI(const char* _id):
                LL_ControlSystem(_id),
                finalize_done(false),
                is_armed(false),
                td(new TestDescription)
        {
                setDefaults( td );
                memset(tstats, 0, sizeof(tstats));
        }
        virtual ~LL_ControlSystemI();

        virtual int addCard(ACQ196* _acq196){
                acq196.push_back(_acq196);
                return acq196.size();
        }
        virtual int addCard(AO32* _ao32){
                ao32.push_back(_ao32);
                return ao32.size();
        }
        virtual int getAI_count(void) const;
        virtual int getAO_count(void) const;
        virtual int getDI_count(void) const;
        virtual int getDO_count(void) const;
        virtual int getStatus_count(void) const;

        virtual void init(int argc, const char* argv[]);
        virtual int Arm(const short* ao_values_init, const unsigned* do_values_init);
        virtual int IO(const short* ao_values, const unsigned* do_values,
                        short* ai_values, unsigned* di_values, unsigned *status);
        virtual int Stop();

        virtual void print();

        virtual int getSamples() const {
                return td->iterations;                  /* iterations==#samples */
        }

        virtual int getOffset(ACQ_Card* card, enum IO io);
};

int LL_ControlSystemI::getOffset(ACQ_Card* card, enum IO io)
{
        int offset;
        int channels_per_element = 1;

        switch(io){
        case AI:
                offset = lookupOffset(AI_cursors, card);
                break;
        case AO:
                offset = lookupOffset(AO_cursors, card);
                break;
        case DI:
                offset = lookupOffset(DI_cursors, card);
                channels_per_element = BITS_PER_DX_WORD;
                break;
        case DO:
                offset = lookupOffset(DO_cursors, card);
                channels_per_element = BITS_PER_DX_WORD;
                break;
        case ST:
                offset = lookupOffset(ST_cursors, card);
                break;
        }

        if (offset >= 0){
                offset /= channels_per_element;
        }
        return offset;
}

int LL_ControlSystemI::getAI_count(void) const
{
        int ai_count = 0;
        FOREACH(ii, acq196){
                ai_count += acq196[ii]->getAI_count();
        }
        return ai_count;
}
int LL_ControlSystemI::getAO_count(void) const
{
        int ao_count = 0;
        FOREACH(ii, acq196){
                ao_count += acq196[ii]->getAO_count();
        }
        FOREACH(ii, ao32){
                ao_count += ao32[ii]->getAO_count();
        }
        return ao_count;
}
int LL_ControlSystemI::getDI_count(void) const
{
        int di_count = 0;
        FOREACH(ii, acq196){
                di_count += acq196[ii]->getDI_count();
        }
        return di_count;

}
int LL_ControlSystemI::getDO_count(void) const
{
        int do_count = 0;
        FOREACH(ii, ao32){
                do_count += ao32[ii]->getDO_count();
        }
        return do_count;
}
int LL_ControlSystemI::getStatus_count(void) const
{
        int st_count = 0;
        FOREACH(ii, acq196){
                st_count += acq196[ii]->getStatus_count();
        }
        FOREACH(ii, ao32){
                st_count += ao32[ii]->getStatus_count();
        }
        return st_count;
}
int LL_ControlSystemI::lookupOffset(
                vector<ClientBufCursor*> cursors, const ACQ_Card* card)
{
        FOREACH(ii, cursors){
                if (cursors[ii]->card.getSlot() == card->getSlot()){
                        return cursors[ii]->client_offset;
                };
        }
        return -1;
}


void LL_ControlSystemI::printClientOffset(
                const char *id, int offset)
{
        if (offset >= 0){
                cerr << id << " " << offset  << endl;
        }
}
void LL_ControlSystemI::printClientOffsets(ACQ_Card* card)
{
        printClientOffset("\tAI", getOffset(card, AI));
        printClientOffset("\tAO", getOffset(card, AO));
        printClientOffset("\tDI", getOffset(card, DI));
        printClientOffset("\tDO", getOffset(card, DO));
        printClientOffset("\tST", getOffset(card, ST));
}

void LL_ControlSystemI::simple_print() {
        cerr << id << endl;
        FOREACH(ii, acq196){
                acq196[ii]->print();
                printClientOffsets(acq196[ii]);
        }
        FOREACH(ii, ao32){
                ao32[ii]->print();
                printClientOffsets(ao32[ii]);
        }
}


char* indent(int level)
{
        static char space[80];
        int ic;

        if (level > 80) level = 80;

        for (ic = 0; ic < level; ++ic){
                space[ic] = ' ';
        }
        space[ic] = '\0';
        return space;
}

ofstream xml;

void LL_ControlSystemI::print_xml(enum IO io, int len, int offset)
{
        if (len > 0){
                xml << indent(8) << "<data class=\"" << ::IO(io) << "\" len=\"" <<
                        len << "\" offset=\"" << offset << "\" />" << endl;
        }
}
void LL_ControlSystemI::print_xml(ACQ_Card* card, enum IO io)
{
        int len;
        int offset = getOffset(card, io);

        switch(io){
        case AI:
                len = card->getAI_count(); break;
        case AO:
                len = card->getAO_count(); break;
        case DI:
                len = card->getDI_count(); break;
        case DO:
                len = card->getDO_count(); break;
        case ST:
                len = card->getStatus_count(); break;
        }

        print_xml(io, len, offset);
}
void LL_ControlSystemI::print_xml(ACQ_Card* card, const char* typ)
{
        xml << indent(4) << "<card class=\"" << typ << "\" slot=\"" <<
                                card->getSlot() << "\" >" << endl;
        print_xml(card, AI);
        print_xml(card, AO);
        print_xml(card, DI);
        print_xml(card, DO);
        print_xml(card, ST);

        xml << indent(4) << "</card>" << endl;
}

class UnixQuery {
        char buf[80];
public:
        UnixQuery(const char* command) {
                FILE *fp = popen(command, "r");
                assert(fp != 0);
                assert(fgets(buf, 80, fp));
                pclose(fp);
                for (int ic = strlen(buf)-1; ic >=0; --ic){
                        if (buf[ic] == '\n'){
                                buf[ic] = '\0';
                        }else{
                                break;
                        }
                }
        }
        ~UnixQuery() {
        }
        const char *toString() { return buf; };
};
class Date : public UnixQuery {
public:
        Date() : UnixQuery("date") {
        }
};

class Host : public UnixQuery {
public:
        Host() : UnixQuery("hostname") {}
};

class User : public UnixQuery {
public:
        User() : UnixQuery("whoami") {}
};

void LL_ControlSystemI::print_xml(LL_ControlSystemI* sys, const char* typ)
{
        Date date;
        Host host;
        User user;

        xml << indent(4) << "<!-- " << "summary defines applications's view of the data " << "-->" <<endl;
        xml << indent(4) << "<!-- summary created by " << user.toString() << "@" << host.toString() << " " << date.toString() << "-->" << endl;
        xml << indent(4) << "<!-- API version " << VERID <<  "-->" << endl;
        xml << indent(4) << "<summary>" << endl;
        print_xml(AI, getAI_count());
        print_xml(AO, getAO_count());
        print_xml(DI, getDI_count());
        print_xml(DO, getDO_count());
        print_xml(ST, getStatus_count());

        xml << indent(4) << "</summary>" << endl;
        if (stuff){
                xml << stuff;
        }
}


#define NL      "\n"

void LL_ControlSystemI::print_xml()
{
        int level = 0;
const char* offset_help = NL
"function offset for each card is the start offset in the summary vector."      NL
"value set programmatically after the system assembly has been finalized. "             NL
"when instantiating by hand, set to zero, then if the app requires the offset, " NL
"first create the offsets with the \"--print_quit option\", " NL
"then parse the output file to determine the value of the offsets." NL
"This value will be fixed between runs provided the set of cards is unchanged" NL;

        string fname(id);
        fname += ".xml";
        xml.open(fname.c_str());
        xml << "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>" << endl;
        xml << "<system name=\"" << id << "\">" << endl;
        xml << indent(4) << "<!-- WARNING: file overwritten every run" << " -->" << endl;
        xml << indent(4) << "<!-- Cards section defines stock of cards. Can modify by hand -->" <<endl;
        xml << indent(4) << "<!-- " << offset_help << "-->" << endl;

        FOREACH(ii, acq196){
                print_xml(acq196[ii], "acq196");
        }
        FOREACH(ii, ao32){
                print_xml(ao32[ii], "ao32");
        }
        print_xml(this, id);
        xml << "</system>" << endl;
        xml.close();
        cerr << "config:" << fname << " written" << endl;
}
void LL_ControlSystemI::print() {
        finalize();
        if (getenv("LLC2_SIMPLE_PRINT")){
                simple_print();
        }else{
                print_xml();
        }
}


void LL_ControlSystemI::finalize(vector <ACQ_Card*>& cards, int offsets[IONUM])
{
        FOREACH(ii, cards){
                ACQ_Card& card = *cards[ii];
                if (card.getAI_count() != 0){
                        ClientBufCursor* cbc = new ClientBufCursor(card, offsets[AI]);
                        offsets[AI] += card.getAI_count();
                        AI_cursors.push_back(cbc);
                }
                if (card.getAO_count() != 0){
                        ClientBufCursor* cbc = new ClientBufCursor(card, offsets[AO]);
                        offsets[AO] += card.getAO_count();
                        AO_cursors.push_back(cbc);
                }
                if (card.getDO_count() != 0){
                        ClientBufCursor* cbc = new ClientBufCursor(card, offsets[DO]);
                        offsets[DO] += card.getDO_count();
                        DO_cursors.push_back(cbc);
                }
                if (card.getDI_count() != 0){
                        ClientBufCursor* cbc = new ClientBufCursor(card, offsets[DI]);
                        offsets[DI] += card.getDI_count();
                        DI_cursors.push_back(cbc);
                }
                if (card.getStatus_count() != 0){
                        ClientBufCursor* cbc = new ClientBufCursor(card, offsets[ST]);
                        offsets[ST] += card.getStatus_count();
                        ST_cursors.push_back(cbc);
                }
        }
}

void LL_ControlSystemI::finalize()
{
        if (!finalize_done){
                int offsets[IONUM] = {};        /**< index by enum IO. */

                finalize(acq196, offsets);
                finalize(ao32, offsets);

                ACQ196* master = dynamic_cast<ACQ196*>(acq196[0]);
                if (master == 0){
                        cerr << "ERROR: configuration MUST include at least one ACQ196"
                                        <<endl;
                        exit(1);
                }

                FOREACH(ii, acq196){
                        acq196[ii]->init(&td->cards[ii]);
                        td->ncards += 1;
                }
                td->sample_offset = 256;  /* operate on 256 boundaries - easy debug */

                td->sample_size = (getAI_count() + 32) * sizeof(short);
                fprintf(stderr, "M_SYNC_2V sample size %d\n",
                                td_sample_size(td));

                FOREACH(ii, ao32){
                        AO32* slave = dynamic_cast<AO32*>(ao32[ii]);
                        slave->setMaster(master);
                        slave->setIndex(ii);
                        td->ao32_ids[td->ao32_count++] = ao32[ii]->getSlot();
                }

                if ( td->tlog ){
                        int ne = td->iterations;
                        FOREACHCARD{
                                td->stats_buf[icard] = znew<TimingStats>(ne);
                        }
                }
                finalize_done = true;
        }
}
#define HELP \
                "llcontrol [opts] mode \n"\
                "\n"\
                "opts:\n"\
                "    -v verbose  verbose output\n"\
                "    -d decimation {0..15} [default:1]\n"\
                "    -n iterations [default:1]\n"\
                "    -T {+,-} trigger edge [default:-]\n"\
                "    -C {+,-} clock edge   [default:-]\n"\
                "    -M <mask> use this interrupt mask\n"\
                ""

bool suppress_resource_init = false;

void ACQ196::init(Card *_card)
{
        card = _card;
        card->slot = slot;
        card->channels = getAI_count();
        if (suppress_resource_init) return;

        initCardResource(card);
        fprintf(stderr, "ACQ196::init(%p) mbox %p\n", card, card->mbx);
}

void LL_ControlSystemI::setDefaults(TestDescription *td)
{
        memset(td, 0, sizeof(TestDescription));
        td->mode = TestDescription::M_SYNC_2VAO32;
        td->arg.interval = 0;
        td->iterations = 1;
        td->decimation = 1;
        td->overwrite = 0;
        td->clkpos = 1;
        td->trpos = 0;
        td->internal_loopback = 0;

        td->mask_ints = 0;
        td->mask_ints_mask = 0;

        td->update_dacs = 0;
        td->samples = 1;      /* samples > 1 is an acq216 thing */
}

static void setEdge( int* flag, const char* arg )
{
        *flag = arg[0] == '+';
}

void makeIntMasks(TestDescription* td, const char* mask_on)
{
        int len = strlen(mask_on);

        td->mask_ints = 1;
        td->mask_ints_mask = mask_on;
        td->unmask_ints_mask = new char[len+1];
        memset(td->unmask_ints_mask, '0', len);
        td->unmask_ints_mask[len] = '\0';
}


void LL_ControlSystemI::init(int argc, const char* argv[])
{


        const char* arg;
        struct poptOption opt_table[] = {
                        { "verbose",    'v', POPT_ARG_INT,    &verbose,       0         },
                        { "decimation", 'd', POPT_ARG_INT,    &td->decimation, 0,
                                "reduce output rate by N [1]"                                                   },
                        { "iterations", 'n', POPT_ARG_INT,    &td->iterations, 0,
                                "capture samples [1]"                                                                   },
                        { "trgedge",    'T', POPT_ARG_STRING, &arg,          'T',
                                "trigger edge {+|-} [-]"                                                                },
                        { "clkedge",    'C', POPT_ARG_STRING, &arg,          'C',
                                "clock edge {+|-} [-]"                                                                  },
                        { "tstats",     't', POPT_ARG_NONE,   0,             't',
                                "dump timing stats output to text file"                                 },
                        { "tstats_bin", 'b', POPT_ARG_STRING, &td->tlog_binfile, 'b',
                                "dump timing stats output to binary file"                               },
                        { "int_mask",   'M', POPT_ARG_STRING, &arg,          'M',
                                "masks interrupts ff...ff (64 chars) =ALL [0]"                  },
                        { "print_quit", 0,  POPT_ARG_NONE,   0,             'Q',
                                "dump configuration and exit"                                                   },
                        { "monitor",    'm', POPT_ARG_INT,    &monitor,       0,
                                "start a monitor co-routine to show progress"                   },
                        POPT_AUTOHELP
                        POPT_TABLEEND
        };
        poptContext opt_context = poptGetContext(argv[0], argc, argv, opt_table, 0);
        int rc;

        while ((rc = poptGetNextOpt(opt_context)) > 0 ){
                switch( rc ){
                case 'h':
                        fprintf(stderr, VERID "\n");
                        fprintf( stderr, HELP );
                        exit(1);
                case 'T':
                        setEdge(&td->trpos, arg);
                        break;
                case 'C':
                        setEdge(&td->clkpos, arg);
                        break;
                case 'b': case 't':
                        td->tlog++;
                        break;
                case 'M':
                        makeIntMasks(td, arg);
                        break;
                case 'Q':
                        suppress_resource_init = true;
                        print();
                        exit(0);
                        break;
                default:
                        ;
                }
        }

        if ( (arg = poptGetArg( opt_context )) == NULL ){
                td->arg.divisor = 100;
        }else{
                td->arg.divisor = atoi(arg);
        }
        printf("ECM %d\n", td->arg.divisor);

        poptFreeContext(opt_context);
}


void LL_ControlSystemI::prime_ao(const short* ao_values) {
        if (ao_values == NO_VALUE) return;

        FOREACH(ii, AO_cursors){
                ClientBufCursor* cbc = AO_cursors[ii];
                ACQ& card = cbc->card;
                card.putAO(ao_values+cbc->client_offset);
        }
}
void LL_ControlSystemI::gather_ai(short* ai_values) {
        if (ai_values == NO_VALUE) return;

        FOREACH(ii, AI_cursors){
                ClientBufCursor* cbc = AI_cursors[ii];
                ACQ& card = cbc->card;
                card.getAI(ai_values+cbc->client_offset);
        }
}

void LL_ControlSystemI::prime_do(const unsigned* do_values)
{
        if (do_values == NO_VALUE) return;

        FOREACH(ii, DO_cursors){
                ClientBufCursor* cbc = DO_cursors[ii];
                ACQ& card = cbc->card;
                card.putDO(do_values+cbc->client_offset);
        }
}
void LL_ControlSystemI::gather_di(unsigned* di_values)
{
        if (di_values == NO_VALUE) return;

        FOREACH(ii, DI_cursors){
                ClientBufCursor* cbc = DI_cursors[ii];
                ACQ& card = cbc->card;
                card.getDI(di_values+cbc->client_offset);
        }
}
void LL_ControlSystemI::gather_status(unsigned *status)
{
        if (status == NO_VALUE) return;

        FOREACH(ii, ST_cursors){
                ClientBufCursor* cbc = ST_cursors[ii];
                ACQ& card = cbc->card;
                card.getStatus(status+cbc->client_offset);
        }

        if (td->tlog){
                FOREACHCARD{
                        tstats[icard].target_poll = getMboxPollcount(EACHMBX(td));
                        updateTimingStats(
                                        td->stats_buf[icard], td->iter, &tstats[icard]);
                }
        }
}

void LL_ControlSystemI::toggle_wd(void)
{
        dynamic_cast<ACQ196*>(acq196[0])->toggle_wd();
}
#define OFFSET 0

int LL_ControlSystemI::Arm(const short* ao_values, const unsigned* do_values)
{
        finalize();
        setupAbortHandler(td);
        if ( monitor ){
                setupMonitor(monitor);
        }

        prime_ao(ao_values);
        prime_do(do_values);

        FOREACHCARD{
                appEnterLLC_SYNC_2VAO32(THIS_CARD, EACHMBX(td), td);
        }

        FOREACHCARD{
                llSetTlatch(EACHMBX(td), tstats[icard].tlatch = 0xffffffff);
                llv2InitDmaDone(getVaddr(EACHBUF(td),
                                                EACHCARD(td)->sync_2v_offset_status_hsbt));
        }
        cmd = LLC_MAKE_DECIM(td->decimation);


        try {
                FOREACHCARD{
                        updateTargetAddr(cmd+LLC_CSR_M_ARM, EACHCARD(td), OFFSET);
                }
        } catch (int e) {
                fprintf(stderr, "SNACK %08x\n", e);
                exit(1);
        }

        if (td->mask_ints){
                PRINTF(1)( "mask ints %s\n", td->mask_ints_mask );
                FOREACHCARD{
                        acq200_setImask(EACHSLOT(td), td->mask_ints_mask);
                }
        }

        return 0;
}
int LL_ControlSystemI::IO(const short* ao_values, const unsigned* do_values,
                short* ai_values, unsigned* di_values, unsigned *status)
{
        prime_ao(ao_values);
        prime_do(do_values);

        FOREACHCARD{
                tstats[icard].tlatch = waitDmaDone(EACHCARD(td));
        }
        FOREACHCARD{
                updateTstats(cmd, EACHCARD(td), &tstats[icard]);
        }

        gather_ai(ai_values);
        gather_di(di_values);
        gather_status(status);
        toggle_wd();
        ++td->iter;
        return 0;
}
int LL_ControlSystemI::Stop()
{
        if (td->mask_ints){
                PRINTF(1)( "mask ints 0x%04x\n", td->mask_ints_mask);
                FOREACHCARD{
                        acq200_setImask(EACHSLOT(td), td->unmask_ints_mask);
                }
        }
        try {
                FOREACHCARD{
                        leaveLLC(EACHMBX(td));
                }
        } catch (int e) {
                fprintf(stderr, "SNACK %08x\n", e);
                exit(1);
        }
}


template<class T>  void deleteClear(vector<T*>& vec){
        FOREACH(ii, vec){
                delete vec[ii];
        }
        vec.clear();
}

LL_ControlSystemI::~LL_ControlSystemI()
{
        printf("~LL_ControlSystemI()\n");
        doPostShotAnalysis(td);

        deleteClear<ClientBufCursor>(AO_cursors);
        deleteClear<ClientBufCursor>(AI_cursors);
        deleteClear<ClientBufCursor>(DO_cursors);
        deleteClear<ClientBufCursor>(DI_cursors);
        deleteClear<ClientBufCursor>(ST_cursors);
        deleteClear<ACQ_Card>(ao32);
        deleteClear<ACQ_Card>(acq196);
}
LL_ControlSystem& LL_ControlSystem::create(const char *_id)
{
        return *new LL_ControlSystemI(strcpy(new char[strlen(_id)+1], _id));
}

const char* getAttribute(XMLNode& node, const char* attribute)
{
        const char* attr = node.getAttribute(attribute);
        if (attr == NULL){
                fprintf(stderr, "ERROR in xml node:\"%s\" missing attribute \"%s\"\n",
                                node.getName(), attribute);
                exit(-1);
        }
        return attr;
}

static char *newstr(const char* oldstr){
        return strcpy(new char[strlen(oldstr)+1], oldstr);
}

static int makeArgs(const XMLNode& runtime, char*** p_argv)
{
        int nargs = runtime.nChildNode("arg")*2+1;
        if (nargs == 0) return 0;
        char** argv = new char* [++nargs];
        int ii = 0;

        argv[ii++] = newstr("ll2");

        for (; ii < nargs; ++ii){
                /** three possibilities, all work:
                 * --key
                 * --key value
                 * value
                 */
                XMLNode arg = runtime.getChildNode("arg", ii-1);
                const char* key = arg.getAttribute("key");
                if (key){
                        argv[ii++] = newstr(key);
                }
                const char* value = arg.getAttribute("value");
                if (value){
                        argv[ii++] = newstr(value);
                }
        }
        *p_argv = argv;
        return nargs;
}
LL_ControlSystem& LL_ControlSystem::createFromFile(const char *config_file)
/**< factory method
 * @param init_file names xml state file that pre-defines the system.
 * */
{
        XMLNode root = XMLNode::openFileHelper(config_file, "system");
        LL_ControlSystem& the_system = create(getAttribute(root, "name"));
        int ncards = root.nChildNode("card");

        for (int ic = 0; ic < ncards; ++ic){
                int AI = 0;
                int AO = 0;
                int DO = 0;
                int DI = 0;
                XMLNode card = root.getChildNode("card", ic);
                int slot = atoi(getAttribute(card, "slot"));
                const char* acq_class = getAttribute(card, "class");
                printf("slot:%d class:%s\n", slot, acq_class);

                int ndata = card.nChildNode("data");
                for (int id = 0; id < ndata; ++id){
                        XMLNode data = card.getChildNode("data", id);
                        const char* dclass = getAttribute(data, "class");
                        int dlen = atoi(getAttribute(data, "len"));

                        if (strcmp(dclass, "AI") == 0){
                                AI = dlen;
                        }else if (strcmp(dclass, "AO") == 0){
                                AO = dlen;
                        }else if (strcmp(dclass, "DI") == 0){
                                DI = dlen;
                        }else if (strcmp(dclass, "DO") == 0){
                                DO = dlen;
                        }else{
                                ;
                        }
                }

                if (strcmp(acq_class, "acq196") == 0){
                        the_system.addCard(new ACQ196(slot, AI, DI, AO, DO));
                }else if (strcmp(acq_class, "ao32") == 0){
                        the_system.addCard(new AO32(slot, AO, DO));
                }else{
                        fprintf(stderr, "ERROR: bad acq_class \"%s\"\n", acq_class);
                }
        }
        XMLNode runtime = root.getChildNode("runtime");
        if (!runtime.isEmpty()){
                char **argv;
                int argc = makeArgs(runtime, &argv);
                stuff = runtime.createXMLString();
                the_system.init(argc, (const char**)argv);
        }
        return the_system;
}


void LL_ControlSystem::closedown(LL_ControlSystem& sys)
{
        delete &sys;
}