Subversion Repositories simple_customized_counter

// ===================================================================
// This is a library of counters
// ===================================================================
// Each counter supports:
//    - Resetting
//    - Counting up
//    - Counting down
//    - Loading a value from the input iLoadValue
//
// The code is straightforward, so you can easily create your own counter
//      by changing the counter type or the operations. In fact you can 
//      create any functions like a shift register or even an 
//      ALU (Arithmetic and Logic Unit) or a calculator.
//
// The output always generates an event.
//     If you don't want the event, remove the colon ':' in the assignment.
//         Ex: change oValue := 0; to oValue = 0;
//
// ===================================================================
// There are four counters in the library.
//
//   The first two executes the operation on input events:
//    - CCounterEvent:    operations depends on inputs: iReset, iUp, iDown, iLoad
//    - CCounterOprEvent: operations depends on a single input:  iOpr
//
//   The last two executes the operation at each step i.e. FPGA clock:
//    - CCounterLevel:    operations depends on inputs: iReset, iUp, iDown, iLoad 
//    - CCounterOprLevel: operations depends on a single input:  iOpr
//
// ===================================================================
// TEST BENCHES:
//
//    - CCounterEvent:    Manual test with control panel
//                            Project in "TestCounterEvent" folder
//
//    - CCounterOprEvent: Simulated DE1SoC board, you need the BSP
//                        Real DE1SoC board,      you need the real board
//                            Project in "TestCounterOprEventBoard" folder
//                        Performed by a C++ program
//                            Project in "TestCounterOprEventAPI" folder
//                            << This project requires a paid license >>
//
//    - CCounterLevel:    Using signal editor and viewer
//                            Project in "TestCounterLevel" folder
//
//    - CCounterOprLevel: Using signal editor and viewer
//                            Project in "TestCounterOprLevel" folder
// ===================================================================

library CounterLib
{
    // -------------------------------------------------------------------
    // This counter executes the operation on input events
    // There is a priority assigned to each function, in parenthesis
    //    0 indicates highest priority
    //      and priority decreases with increasing value
    // -------------------------------------------------------------------
    component CCounterEvent (in  active  bit   iReset,
                             in  active  bit   iUp,
                             in  active  bit   iDown,
                             in  active  bit   iLoad,
                             in  passive ubyte iLoadValue,
                             out active  ubyte oValue)
    {
        DoReset(0) on iReset 
        {
            oValue := 0ub;
        }

        CountUp(1) on iUp 
        {
            oValue:++;
        }

        CountDown(2) on iDown 
        {
            oValue:--;
        }

        LoadValue(3) on iLoad 
        {
            oValue := iLoadValue;
        }
    };
        
    // -------------------------------------------------------------------
    // This counter executes the operation at each step or FPGA clock cycle
    // The priority is implemented with if and else instructions
    // -------------------------------------------------------------------
    component CCounterLevel (in  passive bit   iReset,
                             in  passive bit   iUp,
                             in  passive bit   iDown,
                             in  passive bit   iLoad,
                             in  passive ubyte iLoadValue,
                             out active  ubyte oValue)
    {
        always()
        {
            if(iReset) 
            {
                oValue := 0ub;
            }

            else if(iUp)   
            {
                oValue:++;
            }

            else if(iDown)   
            {
                oValue:--;
            }

            else if(iLoad)   
            {
                oValue := iLoadValue;
            }
        }
    };

    // -------------------------------------------------------------------
    // Define type and constants for the counter operation
    // -------------------------------------------------------------------
    enum Opr_t { cOprNone, cOprReset, cOprUp, cOprDown, cOprLoad }; 

    // -------------------------------------------------------------------
    // This counter executes the operation on input events.
    // The input iOpr has the type Opr_t and determines the operation.
    // There is no priority on the operation.
    // -------------------------------------------------------------------
    // The switch statement has no break, only one case is executed
    // -------------------------------------------------------------------
    component CCounterOprEvent (in  active  Opr_t iOpr,
                                in  passive ubyte iLoadValue,
                                out active  ubyte oValue)
    {
        ExecuteOpr(0) on iOpr 
        {
            // The switch statement has no break, only one case is executed
            switch(iOpr)
            {
                case cOprReset: oValue:= 0ub;
                case cOprUp:    oValue:++;
                case cOprDown:  oValue:--;
                case cOprLoad:  oValue := iLoadValue;
            }
        }
    };
        
    // -------------------------------------------------------------------
    // This counter executes the operation at each step or FPGA clock cycle
    // The input iOpr has the type Opr_t and determines the operation
    // There is no priority on the operations
    // -------------------------------------------------------------------
    component CCounterOprLevel (in  active  Opr_t iOpr,
                                in  passive ubyte iLoadValue,
                                out active  ubyte oValue)
    {
        always()
        {
            // Send the event
            oValue:; 

            // Assign the value
            // The switch instruction returns a value
            oValue = switch(iOpr)   
                     {
                         case cOprReset: 0ub;
                         case cOprUp:    oValue + 1ub;
                         case cOprDown:  oValue - 1ub;
                         case cOprLoad:  iLoadValue;
                     };
        }
    };
};