i2cms.cpp

Microsoft WinCE 6.0 BSP FINAL release source code for use with the i.MX27ADS TO2 WCE600_FINAL_MX27_S

//-----------------------------------------------------------------------------
//
// i2capp.cpp
// This unit test program demonstrates how to use I2C driver in both master and
// slave mode.
// See Usage() below for arguments, options, etc.
// 
//-----------------------------------------------------------------------------
#include <windows.h>
#include <ceddk.h>
#include "i2cbus.h"


//-----------------------------------------------------------------------------
// Defines
//-----------------------------------------------------------------------------
#define dprintf NKDbgPrintfW

// Configurable I2C value
// I2C_DEVICE_NAME range I2C1:I2C2:I2C3:
#define I2C_DEVICE_NAME         _T("I2C1:")

// I2C_SCLK_FREQ range 0~400000
#define I2C_SCLK_FREQ           3000

// I2C_ADDR_MASTER range 0x01 ~ 0x7f
#define I2C_ADDR_MASTER         0x10

// I2C_ADDR_SLAVE range 0x01 ~ 0x7f
#define I2C_ADDR_SLAVE          0x12

#define I2C_TEST_BUF_SIZE   512

#define NELEMS(x) (sizeof(x)/sizeof((x)[0]))

//-----------------------------------------------------------------------------
// Variables
//-----------------------------------------------------------------------------
static HANDLE hI2C;


//-----------------------------------------------------------------------------
// MasterFunc
//
// The function for I2C master
//-----------------------------------------------------------------------------
void MasterFunc(void)
{
    // Set the master modes
    if ( I2CSetMasterMode(hI2C) == FALSE )
        dprintf(TEXT("I2CSetMasterMode failed.\r\n"));
    
    // Set frequency
    if ( I2CSetFrequency(hI2C, I2C_SCLK_FREQ) == FALSE )
        dprintf(TEXT("I2CSetFrequency(%d) failed.\r\n"), I2C_SCLK_FREQ);

    // Set self address
    if ( I2CSetSelfAddr( hI2C, I2C_ADDR_MASTER ) == FALSE )
        dprintf(TEXT("I2CSetSelfAddr(%d) failed.\r\n"), I2C_ADDR_MASTER);

    // Transfer data
    INT iResult;
    INT iResultB;
    I2C_TRANSFER_BLOCK I2CXferBlock;

    I2C_PACKET PacketA [1] = 
    {
        {
            I2C_ADDR_SLAVE, 
            I2C_RW_WRITE, 
            NULL, 
            0, 
            &iResult
        }
    };

    I2C_PACKET PacketB[2] = 
    {
        {
            I2C_ADDR_SLAVE, 
            I2C_RW_READ, 
            NULL, 
            0, 
            &iResultB
        }, 
        {
            I2C_ADDR_SLAVE, 
            I2C_RW_WRITE, 
            NULL, 
            0, 
            &iResult
        },
    };

    BYTE TxData[I2C_TEST_BUF_SIZE]; 
    BYTE RxData[I2C_TEST_BUF_SIZE];

    static int i;

#ifdef TEST_A
    PacketA[0].pbyBuf = &TxData[start];
    PacketA[0].wLen = 3;
    I2CXferBlock.pI2CPackets = &PacketA[0];
    I2CXferBlock.iNumPackets = 1;
    dprintf(TEXT("<%d> Master is sending (%d, %d, %d). "), 
        i+1, TxData[start], TxData[start+1] , TxData[start+2]);

    iResult= -1;
        dprintf(TEXT("Master ing sent"));

    I2CTransfer( hI2C, &I2CXferBlock);

    if (iResult == I2C_NO_ERROR)
        dprintf(TEXT("Master data sent"));
    else
        dprintf(TEXT("Transfer error %d"), iResult);
#else

    // this test has master transmit 512 bytes (FF -> 0) then slave tx 2 bytes
    for( i=0; i<sizeof(TxData);i++ )
    {
        TxData[i] = (BYTE)((0xFF-i)&0xFF);
    }
    memset(&RxData, 0, sizeof(RxData));

    PacketB[1].byAddr = I2C_ADDR_SLAVE;
    PacketB[1].pbyBuf = &TxData[0];
    PacketB[1].wLen = I2C_TEST_BUF_SIZE;

    PacketB[0].byAddr = I2C_ADDR_SLAVE;
    PacketB[0].pbyBuf = &RxData[0];
    PacketB[0].wLen = 2; 

    I2CXferBlock.pI2CPackets = &PacketB[0];
    I2CXferBlock.iNumPackets = 2;

    dprintf(TEXT("Master is reading %d bytes.\r\n"), PacketB[0].wLen);

    iResult= -999;
    iResultB= -9999;

    if ( I2CTransfer( hI2C, &I2CXferBlock) == FALSE )
        dprintf(TEXT("I2CTransfer failed.\r\n"));

    if (iResultB == I2C_NO_ERROR)
    {
        dprintf(TEXT("Receive %d bytes OK. "), PacketB[0].wLen);
    }
    else
    {
        dprintf(TEXT("Receive error %d. "), iResultB);
    }

    dprintf(TEXT("Data is (%d, %d, %d, %d, %d ... %d, %d, %d, %d, %d)\r\n"), 
        RxData[0],RxData[1],RxData[2],
        RxData[3],RxData[4], 
        RxData[I2C_TEST_BUF_SIZE-5],
        RxData[I2C_TEST_BUF_SIZE-4],
        RxData[I2C_TEST_BUF_SIZE-3],
        RxData[I2C_TEST_BUF_SIZE-2],
        RxData[I2C_TEST_BUF_SIZE-1]);

    dprintf(TEXT("Master is sending %d bytes (%d, %d, %d ... %d, %d, %d)"),  
            PacketB[1].wLen,
            TxData[0], TxData[1], TxData[2],
            TxData[I2C_TEST_BUF_SIZE-3], 
            TxData[I2C_TEST_BUF_SIZE-2], 
            TxData[I2C_TEST_BUF_SIZE-1]
            );
       
    if (iResult == I2C_NO_ERROR)
    {
        dprintf(TEXT("Transmit %d bytes OK.\r\n"), PacketB[0].wLen);
    }
    else
    {
        dprintf(TEXT("Transmit error %d.\r\n"), iResult);
    }

#endif
}


//-----------------------------------------------------------------------------
// SlaveApp
//
// The function for I2C slave test Event notification
//-----------------------------------------------------------------------------
void SlaveAppTest(void)
{
        DWORD dwBufSize;
        BYTE byText[I2C_TEST_BUF_SIZE]; 
        HANDLE hEvent;
        DWORD dwLen;
        int i;

        dwBufSize= I2C_TEST_BUF_SIZE;

        hEvent = CreateEvent(NULL, TRUE, FALSE, L"EVENT_I2C1SLAVE");
        if (hEvent == NULL)
        {
            dprintf(TEXT("Can not create slave event\r\n"));
        }
        else {
            i=0;
            while( i<3 )
            {
                // initially null out the receive buffer
                memset(byText, 0, sizeof(byText));

                if( WaitForSingleObject(hEvent, INFINITE)== WAIT_OBJECT_0)
                {
                    ++i;
                    if ( I2CGetSlaveText(hI2C, byText, dwBufSize, &dwLen) == FALSE )
                        dprintf(TEXT("I2CGetSlaveText(%d bytes) failed\r\n"),
                                dwBufSize);

                    dprintf(TEXT("slave received %d bytes: %d.%d.%d.%d.%d ... %d.%d.%d.%d.%d\r\n"),
                        dwLen,
                        byText[0],byText[1],byText[2],byText[3],byText[4],
                        byText[I2C_TEST_BUF_SIZE-5],
                        byText[I2C_TEST_BUF_SIZE-4],
                        byText[I2C_TEST_BUF_SIZE-3],
                        byText[I2C_TEST_BUF_SIZE-2],
                        byText[I2C_TEST_BUF_SIZE-1]);
                }
            }
        }
        CloseHandle(hEvent);
}

//-----------------------------------------------------------------------------
// SlaveFunc
//
// The function for I2C slave
//-----------------------------------------------------------------------------
void SlaveFunc(void)
{
    BYTE byText[I2C_TEST_BUF_SIZE];


    // set up slave buffer with 0->FF
    for( int i=0; i<I2C_TEST_BUF_SIZE; ++i )
    {
        byText[i]= i &0xFf;
    }
    
    if ( I2CSetSelfAddr(hI2C, I2C_ADDR_SLAVE) == FALSE )
        dprintf(TEXT("I2CSetSelfAddr(%d) failed\r\n"), I2C_ADDR_SLAVE);

    if ( I2CSetSlaveSize( hI2C, I2C_TEST_BUF_SIZE) == FALSE )
        dprintf(TEXT("I2CSetSlaveSize(%d bytes) failed\r\n"), I2C_TEST_BUF_SIZE);

    if ( I2CSetSlaveText( hI2C, byText, I2C_TEST_BUF_SIZE) == FALSE )
        dprintf(TEXT("I2CSetSlaveText(%d bytes) failed\r\n"), I2C_TEST_BUF_SIZE);

    if ( I2CEnableSlave(hI2C) == FALSE )
        dprintf(TEXT("I2CEnableSlave failed\r\n") );


    SlaveAppTest();
}


//-----------------------------------------------------------------------------
// Usage
//
// Prints brief usage instructions
//-----------------------------------------------------------------------------
void Usage(void)
{
    int i;

    static PTSTR usage_text[] = 
    {
        TEXT("Usage: i2capp {-m | -s | -h}"), 
        TEXT(""), 
        TEXT("           -m    master"), 
        TEXT("           -s    slave"), 
        TEXT("           -h    help")
    };

    for (i = 0; i < NELEMS(usage_text); i++)
    {
        dprintf(TEXT("%s\r\n"), usage_text[i]);
    }
}


//-----------------------------------------------------------------------------
// WinMain
//
// The main function
//-----------------------------------------------------------------------------
int WINAPI WinMain ( HINSTANCE hInstance, HINSTANCE hPrevInstance, 
    LPTSTR pCmdLine, int nCmdShow)
{
    // Parse command line
    TCHAR ws[] = TEXT(" \t");
    PTSTR pOption = _tcstok(pCmdLine, ws);
    TCHAR cFlag = pOption[1];
    BOOL bMaster;
    BOOL bInvalid = FALSE;

    switch (cFlag)
    {
    case 'm':
        bMaster = TRUE;
        break;

    case 's':
        bMaster = FALSE;
        break;

    case '?':
    case 'h':
        Usage();
        bInvalid = TRUE;
            break;

    default:
        dprintf(TEXT("Unrecognized option %s\r\n"), pOption);
        Usage();
        bInvalid = TRUE;
        break;
    }

    if (bInvalid)
    {
        // we've already issued complaint, now just exit
        return -1;
    }
    
    // Create I2C file handle
    hI2C = I2COpenHandle( I2C_DEVICE_NAME );
    dprintf(TEXT("Create I2C file %s\r\n"),I2C_DEVICE_NAME );

    if (hI2C == INVALID_HANDLE_VALUE)
    {
        dprintf(TEXT("Create I2C file handle failed \r\n"));
        return -1;
    }

    if (bMaster)
        MasterFunc();
    else
        SlaveFunc();

    // Close the I2C file handle
    if (hI2C != NULL)
    {
        I2CCloseHandle(hI2C);
    }

    dprintf(TEXT("i2capp quit.\r\n"));

    return 0;
}