tb_codec_on_a_stick.cc
// INCLUDE SMI CHANNEL

#include "smi_channel.h"

// INCLUDE EXCEPTION HANDLING

#include "smi_exception.h"

// INCLUDE MODELS

#include "tb_processor.h"
#include "tb_codec.h"
#include "SRAM.h"

// INCLUDE THE REGISTER SET

#include "cos.h"

//********************************
// EXECUTABLE: tb_codec_on_a_stick
//********************************

int
main(int argc, char** argv)
{
    try {
        // INITIALIZE SMI

        SMI_Channel* channel = SMI_Channel::initial(argc, argv);

        // CREATE WRITE AND READ CHANNEL STORAGE

        TB_Values adc, dac;

        // INITIALIZE CHANNEL DATA

        adc.sequence(10, 0x0FFFF, 0x0ADC0);
        dac.sequence(10, 0x0FFFF, 0x0DAC0);

        // CREATE A SERIAL CODEC MODEL

        TB_Codec codec("codec", adc, dac);

        // CREATE A PROCESSOR MODEL

        TB_Processor processor("processor", adc, dac);

        // CREATE TRANSMIT AND RECEIVE FIFO MEMORY MODELS

        SRAM transmit_fifo("transmit_fifo");
        SRAM receive_fifo("receive_fifo");

        // HANDLE CONTROL-C

        channel->signal();

        // ADVERTIZE MODELS TO THE HARDWARE SIMULATION

        channel->post();
        cout << "tb_codec_on_a_stick: initialized" << endl;

        // WAIT FOR THE PROCESSOR TO CONFIGURE

        processor.idle();

        // SET THE INTERRUPT WATERMARK LEVEL

        processor.out(COS::Level, 3);

        // ENABLE AND CONFIGURE THE DATA CHANNELS FOR INTERRUPTS

        processor.out(COS::Receive,  COS::Enable | COS::IruptMask);
        processor.out(COS::Transmit, COS::Enable | COS::IruptMask);

        // LOOP UNTIL BOTH DATA CHANNELS HAVE TRANSFERED ALL THEIR DATA

        while( !dac.is_full() || !adc.is_full())
            processor.idle();

        // PRINT WHETHER READ (ADC) CHANNEL DATA TRANSFERED CORRECTLY

        cout << "tb_codec_on_a_stick: ADC test " << (adc.is_equal() ? "passed" : "failed") << endl;

        // PRINT WHETHER WRITE (DAC) CHANNEL DATA TRANSFERED CORRECTLY

        cout << "tb_codec_on_a_stick: DAC test " << (dac.is_equal() ? "passed" : "failed") << endl;

        // SET EXIT FLAG THEN WAIT FOR SIMULATION TO TERMINATE

        channel->setExiting();
        while(1)
            processor.idle();
    }

    // CATCH EXCEPTIONS

    catch (SMI_Exception& exception)
    {
        cout << exception;
        cout << "Hit return";
        cin.get();
    }

    // CATCH SHUTDOWN

    catch (SMI_Shutdown&)
    {
        cout << "SMI: shutdown (hit return)";
        cin.get();
    }
}
© Copyright 2000-2001 Adrian Lewis