TMS320F280049C: LAUNCHXL-F280049C+BOOSTXL-POSMGR+TFORMAT can't work

ren ken

Part Number: TMS320F280049C
Other Parts Discussed in Thread: BOOSTXL-POSMGR, LAUNCHXL-F280049C

my LAUNCHXL-F280049C+BOOSTXL-POSMGR+TFORMAT can't work well. I find someone had same question, but I don't know how did he do?

my code :

void PM_tformat_setupPeriph(uint32_t devLSPCLKFreq)//r
{
tformat_resetCLB();
tformat_initCLB1();

CLB_configLocalInputMux(CLB1_BASE, CLB_IN0, CLB_LOCAL_IN_MUX_GLOBAL_IN);
CLB_configLocalInputMux(CLB1_BASE, CLB_IN1, CLB_LOCAL_IN_MUX_GLOBAL_IN);
CLB_configLocalInputMux(CLB1_BASE, CLB_IN2, CLB_LOCAL_IN_MUX_GLOBAL_IN);
CLB_configLocalInputMux(CLB1_BASE, CLB_IN3, CLB_LOCAL_IN_MUX_GLOBAL_IN);
CLB_configLocalInputMux(CLB1_BASE, CLB_IN4, CLB_LOCAL_IN_MUX_GLOBAL_IN);
CLB_configLocalInputMux(CLB1_BASE, CLB_IN5, CLB_LOCAL_IN_MUX_GLOBAL_IN);
CLB_configLocalInputMux(CLB1_BASE, CLB_IN6, CLB_LOCAL_IN_MUX_GLOBAL_IN);
CLB_configLocalInputMux(CLB1_BASE, CLB_IN7, CLB_LOCAL_IN_MUX_GLOBAL_IN);

CLB_configGlobalInputMux(CLB1_BASE, CLB_IN0, CLB_GLOBAL_IN_MUX_EPWM4A);//r
CLB_configGlobalInputMux(CLB1_BASE, CLB_IN1, CLB_GLOBAL_IN_MUX_CLB_AUXSIG0);//
CLB_configGlobalInputMux(CLB1_BASE, CLB_IN2, CLB_GLOBAL_IN_MUX_EPWM4A);//
CLB_configGlobalInputMux(CLB1_BASE, CLB_IN3, CLB_GLOBAL_IN_MUX_EPWM4A);//
CLB_configGlobalInputMux(CLB1_BASE, CLB_IN4, CLB_GLOBAL_IN_MUX_EPWM4A);//
CLB_configGlobalInputMux(CLB1_BASE, CLB_IN5, CLB_GLOBAL_IN_MUX_EPWM4A);//
CLB_configGlobalInputMux(CLB1_BASE, CLB_IN6, CLB_GLOBAL_IN_MUX_EPWM4A);//
CLB_configGlobalInputMux(CLB1_BASE, CLB_IN7, CLB_GLOBAL_IN_MUX_EPWM4A);//

CLB_configGPInputMux(CLB1_BASE, CLB_IN0, CLB_GP_IN_MUX_GP_REG);
CLB_configGPInputMux(CLB1_BASE, CLB_IN1, CLB_GP_IN_MUX_EXTERNAL);
CLB_configGPInputMux(CLB1_BASE, CLB_IN2, CLB_GP_IN_MUX_EXTERNAL);
CLB_configGPInputMux(CLB1_BASE, CLB_IN3, CLB_GP_IN_MUX_EXTERNAL);
CLB_configGPInputMux(CLB1_BASE, CLB_IN4, CLB_GP_IN_MUX_EXTERNAL);
CLB_configGPInputMux(CLB1_BASE, CLB_IN5, CLB_GP_IN_MUX_EXTERNAL);
CLB_configGPInputMux(CLB1_BASE, CLB_IN6, CLB_GP_IN_MUX_EXTERNAL);
CLB_configGPInputMux(CLB1_BASE, CLB_IN7, CLB_GP_IN_MUX_GP_REG);//CLB_GP_IN_MUX_GP_REG

CLB_enableSynchronization(CLB1_BASE, CLB_IN0);
CLB_enableSynchronization(CLB1_BASE, CLB_IN1);

CLB_selectInputFilter(CLB1_BASE, CLB_IN0, CLB_FILTER_RISING_EDGE);
CLB_selectInputFilter(CLB1_BASE, CLB_IN1, CLB_FILTER_FALLING_EDGE);

tformat_initSPIFIFO(devLSPCLKFreq); // Initialize the SPI only
tformat_initCLBXBAR(); // Initialize the CLB XBARSPI only

}

void PM_tformat_startOperation(void)//wenr
{
EALLOW;
HWREG(CLB1_BASE + CLB_LOGICCTL + CLB_O_LOAD_EN) |= CLB_LOAD_EN_GLOBAL_EN
| CLB_LOAD_EN_STOP;

__asm(" RPT #10 || NOP");
// CLB_setOutputMask(CLB1_BASE, 0x3C, true);
CLB_setOutputMask(CLB1_BASE, 0x3f, true);//r
__asm(" RPT #10 || NOP");
CLB_setGPREG(CLB1_BASE, 0x81);
}

void tformat_setupGPIO(void) {

//
// GPIO1 is SPI Clk slave
//r
GPIO_setMasterCore(1, GPIO_CORE_CPU1);
GPIO_setPinConfig(GPIO_1_EPWM1_B);

//
// GPIO24 is the SPISIMOB
//r
GPIO_setMasterCore(24, GPIO_CORE_CPU1);
GPIO_setPinConfig(GPIO_24_SPIB_SIMO);
GPIO_setQualificationMode(24, GPIO_QUAL_ASYNC);

//
// GPIO31 is the SPISOMIB
//r
GPIO_setMasterCore(31, GPIO_CORE_CPU1);
GPIO_setPinConfig(GPIO_31_SPIB_SOMI);
GPIO_setQualificationMode(31, GPIO_QUAL_ASYNC);

//
// GPIO22 is the SPICLKB
//r
GPIO_setMasterCore(22, GPIO_CORE_CPU1);
GPIO_setPinConfig(GPIO_22_SPIB_CLK);
GPIO_setQualificationMode(22, GPIO_QUAL_ASYNC);

//
// GPIO27 is the SPISTEB
//r
GPIO_setMasterCore(27, GPIO_CORE_CPU1);
GPIO_setPinConfig(GPIO_27_SPIB_STE);
GPIO_setQualificationMode(27, GPIO_QUAL_ASYNC);

//
// GPIO7 is tformat TxEN
//r
GPIO_setMasterCore(7, GPIO_CORE_CPU1);
GPIO_setPinConfig(GPIO_7_OUTPUTXBAR5);

//
// GPIO28 is PwrEN
//r
GPIO_setMasterCore(28, GPIO_CORE_CPU1);
GPIO_setDirectionMode(28, GPIO_DIR_MODE_OUT);
}

void tformat_configXBAR(void)
{
//
// Connect InputXbar-INPUT1 to GPIO24 - SPISIMO
//

XBAR_setInputPin(XBAR_INPUT1, 24);//r

XBAR_setCLBMuxConfig(XBAR_AUXSIG0, XBAR_CLB_MUX01_INPUTXBAR1);//InputXbar-INPUT1 TO XBAR_CLB_MUX01
XBAR_enableCLBMux(XBAR_AUXSIG0, XBAR_MUX01);
XBAR_setOutputMuxConfig(XBAR_OUTPUT5, XBAR_OUT_MUX01_CLB1_OUT4);//r
XBAR_enableOutputMux(XBAR_OUTPUT5, XBAR_MUX01);

}

void tformat_configEPWM1(void) {

//
// Set the PWMA and B high as default values of tformat clk.
// Action on TZ1
//
EPWM_setTripZoneAction(EPWM1_BASE,
EPWM_TZ_ACTION_EVENT_TZA,
EPWM_TZ_ACTION_HIGH);

//
// Action on TZ1
//
EPWM_setTripZoneAction(EPWM1_BASE,
EPWM_TZ_ACTION_EVENT_TZB,
EPWM_TZ_ACTION_HIGH);

//
// Forces a Trip Zone event
//
EPWM_forceTripZoneEvent(EPWM1_BASE, EPWM_TZ_FORCE_EVENT_OST);
}

#define TFORMAT_FREQ_DIVIDER 10

over 1 year ago

0 Lori Heustess over 1 year ago

TI__Guru* 89465 points

Hello,

I won't be able to review all of your code. However I did notice you changed the TFORMAT_FREQ_DIVIDER. It should be the same as the F2837xD since the CLB runs at the same frequency on both devices i.e. TFORMAT_FREQ_DIVIDER should be 20.

Make sure all of the functions which access the tile have been moved to CLB1_BASE. This includes tformat_configureCLBLen which is easy to miss because the source is in the PM_tformat_internal_include.h file.
Do you see any signal on the ePWM1B pin?
Or on SOMI ?

Regards

Lori

0 ren ken over 1 year ago in reply to Lori Heustess

Prodigy 20 points

this is a signal picture of SIMO in F2837XD , but it did not show in F280049C .

0 ren ken over 1 year ago in reply to ren ken

Prodigy 20 points

I would use SPIA

0 Lori Heustess over 1 year ago in reply to ren ken

TI__Guru* 89465 points

Hello,

The F2837xD example is setup for LaunchPad Site 2, and BoosterPack encoder 1.

For F28004x LaunchPad, the SPI-B module is connected to these pins. i.e. pins 54 and 55 on J8/J6 of the LaunchPad.

The schematics for the booster pack can be downloaded from the product page: https://www.ti.com/tool/BOOSTXL-POSMGR

Regards

Lori

0 ren ken over 1 year ago in reply to Lori Heustess

Prodigy 20 points

Lori,

thank you , I think there are some effect on SPIBSIMO ,due to GPIO24 is used for both SPIBSIMO and boot .so I am going to use SPIA ,and connect PWMB4 to SPIA-CLOCK by wire . another puzzle for me is I don't find where is CLB-clk come frome, if it is sysclk ,it maybe is 100MHz, for F28379D it is 200MHz. the CLB TILE1_COUNTER_1_MATCH1_VAL should recalculate. my program look like the CLB clock dosn't work.

0 ren ken over 1 year ago in reply to ren ken

Prodigy 20 points

it runs well in my launchxl-f280049c,

0 ren ken over 1 year ago in reply to ren ken

Prodigy 20 points

I import the empty example of clb and copy these file which are pm_tformat_main.c , pm_tformat_source.c , tformat.c , pm_tformat_f280049c.syscfg into, and using SPIA , connect SPIA-clk to PWMB4 by wire .

0 ren ken over 1 year ago in reply to ren ken

Prodigy 20 points

pm_tformat_main.c

//-----------------------------------------------------------------------------
//  FILE:           PM_tformat-Main.C
//
//  Description:    Example project for using PM tformat Library.
//                  Includes PM_tformat_lib library and corresponding
//                  include files.
//                  Initializes the encoders and performs delay compensation.
//                  Runs tformat command set.
//                  Continuously Read position value in an infinite loop
//
//  Version:        1.0
//
//  Target:         TMS320F28379D
//
//-----------------------------------------------------------------------------
//  Copyright Texas Instruments 锟� 2004-2015
//-----------------------------------------------------------------------------
//  Revision History:
//-----------------------------------------------------------------------------
//  Date      | Description / Status
//-----------------------------------------------------------------------------
// Feb 2019  - Example project for PM T-Format Library Usage
//-----------------------------------------------------------------------------

#include "tformat.h"         // Include file for tformat interface
#include "device.h"
#include "driverlib.h"

uint32_t crcResult;
uint16_t retVal1;       //used for function return val storage and checks
uint32_t position, turns;

void main(void) {

    //
    // Initialize device clock and peripherals
    //
    Device_init();

    //
    // Turn on the module clock.
    //
    Interrupt_disableMaster();

    //
    // Initialize PIE and clear PIE registers. Disables CPU interrupts.
    //
    Interrupt_initModule();

    //
    // Disable pin locks and enable internal pull-ups.
    //
    Device_initGPIO();

    //
    // Initialize the PIE vector table with pointers to the shell Interrupt
    // Service Routines (ISR).
    //
    Interrupt_initVectorTable();

    Interrupt_register(INT_SPIA_RX, &spiRxFIFOISR);

    //
    //Initialization routine for tformat operation - defined in tformat.c
    //Configures the peripherals and enables clocks for required modules
    //Configures GPIO and XBar as needed for t-format operation
    //Sets up the SPI peripheral in tformat data structure and enables interrupt
    //
    Interrupt_enable(INT_SPIA_RX);
    Interrupt_enableMaster();

    tformat_init();

    DEVICE_DELAY_US(800L);

    //
    //Optional function exercising several tformat
    //commands including eeprom accesses
    //
    retVal1 = tformat_exCommands();

//
//Infinite loop to read position using PM_TFORMAT_DATAID3 command
//- returns position and turns information
//
    while(1)
    {
        retVal1 = PM_tformat_setupCommand (PM_TFORMAT_DATAID3, 0, 0, 0);
        PM_tformat_startOperation();
        while(tformatData.dataReady != 1);// {}
        retVal1 = PM_tformat_receiveData(PM_TFORMAT_DATAID3);

        crcResult = PM_tformat_getCRC(0, 80, 8, (uint16_t *)&tformatData.rxPkts,
                    tformatCRCtable, 10);
        crcResult = crcResult ^ (0xFF);
        if(!tformat_checkCRC(crcResult, tformatData.crc))
        {
             ESTOP0;
        }

        //
        //Invert the received bit sequence for position and
        //turns for actual data
        //
        position =
            ((__flip32((uint32_t) tformatData.dataField0) >> 24 ) & 0xFF) |
            ((__flip32((uint32_t) tformatData.dataField1) >> 16 ) & 0xFF00) |
            ((__flip32((uint32_t) tformatData.dataField2) >> 8 )  & 0xFF0000);

        turns =
            ((__flip32((uint32_t) tformatData.dataField4) >> 24 ) & 0xFF) |
            ((__flip32((uint32_t) tformatData.dataField5) >> 16 ) & 0xFF00) |
            ((__flip32((uint32_t) tformatData.dataField6) >> 8 )  & 0xFF0000);

        DEVICE_DELAY_US(400L);
    }
}

//
// End of file
//

0131.pm_tformat_source.c

//#############################################################################
//
// FILE:   PM_tformat_Source.c
//
// Description:Example project for using PM tformat Library.
//              Includes PM_tformat_lib library and corresponding include files
//              Initializes the encoders and performs delay compensation.
//              Runs tformat command set.
//              Continuously Read position value in an infinite loop
//
//  Target:     TMS320F28379D
//
//#############################################################################
// $TI Release: MotorControl SDK v4.00.00.00 $
// $Release Date: Thu Feb 17 18:05:19 CST 2022 $
// $Copyright:
// Copyright (C) 2017-2020 Texas Instruments Incorporated
//
//     http://www.ti.com/ ALL RIGHTS RESERVED
// $
//#############################################################################


#include "driverlib.h"
#include "stdint.h"
#include "PM_tformat_include.h"
#include "PM_tformat_internal_include.h"

#include "clb_config.h"
#include "clb.h"

uint16_t tformat_tile1HLCInstr[CLB_NUM_HLC_INSTR + 1] =
{
    TILE1_HLCINSTR_0,
    TILE1_HLCINSTR_1,
    TILE1_HLCINSTR_2,
    TILE1_HLCINSTR_3,
    TILE1_HLCINSTR_4,
    TILE1_HLCINSTR_5,
    TILE1_HLCINSTR_6,
    TILE1_HLCINSTR_7,
    TILE1_HLCINSTR_8,
    TILE1_HLCINSTR_9,
    TILE1_HLCINSTR_10,
    TILE1_HLCINSTR_11,
    TILE1_HLCINSTR_12,
    TILE1_HLCINSTR_13,
    TILE1_HLCINSTR_14,
    TILE1_HLCINSTR_15,
    TILE1_HLCINSTR_16,
    TILE1_HLCINSTR_17,
    TILE1_HLCINSTR_18,
    TILE1_HLCINSTR_19,
    TILE1_HLCINSTR_20,
    TILE1_HLCINSTR_21,
    TILE1_HLCINSTR_22,
    TILE1_HLCINSTR_23,
    TILE1_HLCINSTR_24,
    TILE1_HLCINSTR_25,
    TILE1_HLCINSTR_26,
    TILE1_HLCINSTR_27,
    TILE1_HLCINSTR_28,
    TILE1_HLCINSTR_29,
    TILE1_HLCINSTR_30,
    TILE1_HLCINSTR_31
};

void tformat_initCLB4(void);
void tformat_resetCLB(void);

void PM_tformat_setupPeriph(uint32_t devLSPCLKFreq)
{
    tformat_resetCLB();
    tformat_initCLB4();

    CLB_configLocalInputMux(CLB4_BASE, CLB_IN0, CLB_LOCAL_IN_MUX_GLOBAL_IN);
    CLB_configLocalInputMux(CLB4_BASE, CLB_IN1, CLB_LOCAL_IN_MUX_GLOBAL_IN);
    CLB_configLocalInputMux(CLB4_BASE, CLB_IN2, CLB_LOCAL_IN_MUX_GLOBAL_IN);
    CLB_configLocalInputMux(CLB4_BASE, CLB_IN3, CLB_LOCAL_IN_MUX_GLOBAL_IN);
    CLB_configLocalInputMux(CLB4_BASE, CLB_IN4, CLB_LOCAL_IN_MUX_GLOBAL_IN);
    CLB_configLocalInputMux(CLB4_BASE, CLB_IN5, CLB_LOCAL_IN_MUX_GLOBAL_IN);
    CLB_configLocalInputMux(CLB4_BASE, CLB_IN6, CLB_LOCAL_IN_MUX_GLOBAL_IN);
    CLB_configLocalInputMux(CLB4_BASE, CLB_IN7, CLB_LOCAL_IN_MUX_GLOBAL_IN);

    CLB_configGlobalInputMux(CLB4_BASE, CLB_IN0, CLB_GLOBAL_IN_MUX_EPWM1A);
    CLB_configGlobalInputMux(CLB4_BASE, CLB_IN1,
                             CLB_GLOBAL_IN_MUX_CLB_AUXSIG0);
    CLB_configGlobalInputMux(CLB4_BASE, CLB_IN2, CLB_GLOBAL_IN_MUX_EPWM1A);
    CLB_configGlobalInputMux(CLB4_BASE, CLB_IN3, CLB_GLOBAL_IN_MUX_EPWM1A);
    CLB_configGlobalInputMux(CLB4_BASE, CLB_IN4, CLB_GLOBAL_IN_MUX_EPWM1A);
    CLB_configGlobalInputMux(CLB4_BASE, CLB_IN5, CLB_GLOBAL_IN_MUX_EPWM1A);
    CLB_configGlobalInputMux(CLB4_BASE, CLB_IN6, CLB_GLOBAL_IN_MUX_EPWM1A);
    CLB_configGlobalInputMux(CLB4_BASE, CLB_IN7, CLB_GLOBAL_IN_MUX_EPWM1A);

    CLB_configGPInputMux(CLB4_BASE, CLB_IN0, CLB_GP_IN_MUX_GP_REG);
    CLB_configGPInputMux(CLB4_BASE, CLB_IN1, CLB_GP_IN_MUX_EXTERNAL);
    CLB_configGPInputMux(CLB4_BASE, CLB_IN2, CLB_GP_IN_MUX_EXTERNAL);
    CLB_configGPInputMux(CLB4_BASE, CLB_IN3, CLB_GP_IN_MUX_EXTERNAL);
    CLB_configGPInputMux(CLB4_BASE, CLB_IN4, CLB_GP_IN_MUX_EXTERNAL);
    CLB_configGPInputMux(CLB4_BASE, CLB_IN5, CLB_GP_IN_MUX_EXTERNAL);
    CLB_configGPInputMux(CLB4_BASE, CLB_IN6, CLB_GP_IN_MUX_EXTERNAL);
    CLB_configGPInputMux(CLB4_BASE, CLB_IN7, CLB_GP_IN_MUX_GP_REG);

    CLB_enableSynchronization(CLB4_BASE, CLB_IN0);
    CLB_enableSynchronization(CLB4_BASE, CLB_IN1);

    CLB_selectInputFilter(CLB4_BASE, CLB_IN0, CLB_FILTER_RISING_EDGE);
    CLB_selectInputFilter(CLB4_BASE, CLB_IN1, CLB_FILTER_FALLING_EDGE);

    tformat_initSPIFIFO(devLSPCLKFreq);   // Initialize the SPI only
    tformat_initCLBXBAR();   // Initialize the CLB XBAR
}

uint16_t PM_tformat_setupCommand(uint16_t tformatDataID, uint16_t eepromAddr,
                                 uint16_t eepromData, uint16_t crcSend)
{
    uint16_t sendClks;
    uint16_t receiveClks;
    uint16_t dummySPIClks;
    uint16_t i;
    uint16_t word1, word2, word3, temp;
    uint16_t addrl, datal;

    tformat_resetCLB();
    tformatData.dataReady = 0;

    word1 = (tformatDataID << 6) | 0x903F;

    switch(tformatDataID)
    {
        case (PM_TFORMAT_DATAID0):
        case (PM_TFORMAT_DATAID1):
        case (PM_TFORMAT_DATAID7):
        case (PM_TFORMAT_DATAID8):
        case (PM_TFORMAT_DATAIDC):

            sendClks = ABIT + PACKET_BITS + IDLE_BITS;
            receiveClks = 6 * PACKET_BITS ;

            if(((sendClks + receiveClks) % 16) == 0)
            {
                tformatData.fifoLevel =  ((sendClks + receiveClks) / 16);
            }
            else
            {
                tformatData.fifoLevel = ((sendClks + receiveClks) / 16) + 1;
            }

            dummySPIClks = (tformatData.fifoLevel * 16) -
                            (sendClks + receiveClks);

            tformat_configureSPILen(15);

            //
            //void tformat_configureCLBLen(uint16_t CLB4_C1_M1,
            // uint16_t CLB4_C1_M2, uint16_t CLB4_R0)
            //
            tformat_configureCLBLen((PACKET_BITS + 2), sendClks,
                                    receiveClks + dummySPIClks);

            tformatData.sdata[0] = word1;
            tformatData.sdata[1] = 0xFFFF;
            tformatData.sdata[2] = 0xFFFF;
            tformatData.sdata[3] = 0xFFFF;
            for (i = 0;i < tformatData.fifoLevel;i++)
            {
                SPI_writeDataNonBlocking(PM_TFORMAT_SPI, tformatData.sdata[i]);
            }

        break;

        case (PM_TFORMAT_DATAID2):

            sendClks = ABIT + PACKET_BITS + IDLE_BITS;
            receiveClks = 4 * PACKET_BITS ;

            if(((sendClks + receiveClks) % 16) == 0)
            {
                tformatData.fifoLevel =  ((sendClks + receiveClks) / 16);
            }
            else
            {
                tformatData.fifoLevel = ((sendClks + receiveClks) / 16) + 1;
            }

            dummySPIClks = (tformatData.fifoLevel * 16) -
                           (sendClks + receiveClks);

            tformat_configureSPILen(15);

            tformat_configureCLBLen((PACKET_BITS + 2), sendClks,
                                    receiveClks + dummySPIClks);

            tformatData.sdata[0] = word1;
            tformatData.sdata[1] = 0xFFFF;
            tformatData.sdata[2] = 0xFFFF;
            tformatData.sdata[3] = 0xFFFF;
            for (i = 0;i < tformatData.fifoLevel;i++)
            {
                SPI_writeDataNonBlocking(PM_TFORMAT_SPI, tformatData.sdata[i]);
            }

        break;

        case (PM_TFORMAT_DATAID3):

            sendClks = ABIT + PACKET_BITS + IDLE_BITS;
            receiveClks = 11 * PACKET_BITS ;

            if(((sendClks + receiveClks) % 16) == 0)
            {
                tformatData.fifoLevel =  ((sendClks + receiveClks) / 16);
            }
            else
            {
                tformatData.fifoLevel = ((sendClks + receiveClks) / 16) + 1;
            }
            dummySPIClks = (tformatData.fifoLevel * 16) -
                            (sendClks + receiveClks);

            tformat_configureSPILen(15);

            //
            //void tformat_configureCLBLen(uint16_t CLB4_C1_M1,
            //uint16_t CLB4_C1_M2, uint16_t CLB4_R0)
            //
            tformat_configureCLBLen((PACKET_BITS + 2), sendClks,
                                    receiveClks + dummySPIClks);

            tformatData.sdata[0] = word1;
            tformatData.sdata[1] = 0xFFFF;
            tformatData.sdata[2] = 0xFFFF;
            tformatData.sdata[3] = 0xFFFF;
            for (i = 0;i < tformatData.fifoLevel;i++)
                {
                    SPI_writeDataNonBlocking(PM_TFORMAT_SPI,
                    tformatData.sdata[i]);
                }

        break;

        case (PM_TFORMAT_DATAIDD):
            sendClks = ABIT + 3 * PACKET_BITS + IDLE_BITS;
            receiveClks = 4 * PACKET_BITS ;

            addrl = (__flip32(eepromAddr) >> 24) & 0xFE;    // busy "0"
            temp = (addrl >> 4) & 0xF;
            word1 = (tformatDataID << 6) | 0x9020 | temp;
            temp = (addrl  & 0xF) << 12;
            word2 = temp | 0x803 | (crcSend << 2);

            if(((sendClks + receiveClks) % 16) == 0)
            {
                tformatData.fifoLevel =  ((sendClks + receiveClks) / 16);
            }
            else
            {
                tformatData.fifoLevel = ((sendClks + receiveClks) / 16) + 1;
            }
            dummySPIClks = (tformatData.fifoLevel * 16) -
                    (sendClks + receiveClks);

            tformat_configureSPILen(15);

            //
            //void tformat_configureCLBLen(uint16_t CLB4_C1_M1,
            //uint16_t CLB4_C1_M2, uint16_t CLB4_R0)
            //
            tformat_configureCLBLen((3 * PACKET_BITS + 2), sendClks,
                    receiveClks + dummySPIClks);

            tformatData.sdata[0] = word1;
            tformatData.sdata[1] = word2;
            tformatData.sdata[2] = 0xFFFF;
            tformatData.sdata[3] = 0xFFFF;
            for (i = 0;i < tformatData.fifoLevel;i++)
            {
                SPI_writeDataNonBlocking(PM_TFORMAT_SPI, tformatData.sdata[i]);
            }

        break;

        case (PM_TFORMAT_DATAID6):

            sendClks = ABIT + 4 * PACKET_BITS + IDLE_BITS;
            receiveClks = 4 * PACKET_BITS ;

            addrl = (__flip32(eepromAddr) >> 24) & 0xFE;    // busy "0"
            datal = (__flip32(eepromData) >> 24) & 0xFF;
            temp = (addrl >> 4) & 0xF;
            word1 = (tformatDataID << 6) | 0x9020 | temp;
            temp = (addrl  & 0xF) << 12;
            word2 = temp | 0x802 | (datal << 2);
            word3 = (crcSend << 8) | 0xFF;

            if(((sendClks + receiveClks) % 16) == 0)
            {
                tformatData.fifoLevel =  ((sendClks + receiveClks) / 16);
            }
            else
            {
                tformatData.fifoLevel = ((sendClks + receiveClks) / 16) + 1;
            }

            dummySPIClks = (tformatData.fifoLevel * 16) -
                    (sendClks + receiveClks);

            tformat_configureSPILen(15);

            tformat_configureCLBLen((4 * PACKET_BITS + 2), sendClks,
                                    receiveClks + dummySPIClks);

            tformatData.sdata[0] = word1;
            tformatData.sdata[1] = word2;
            tformatData.sdata[2] = word3;
            tformatData.sdata[3] = 0xFFFF;
            for (i = 0;i < tformatData.fifoLevel;i++)
            {
                SPI_writeDataNonBlocking(PM_TFORMAT_SPI, tformatData.sdata[i]);
            }

        break;

        default:
            word1 = 0;
        break;

    }
    return(word1);
}

uint16_t PM_tformat_receiveData(uint16_t tformatDataID)
{
    uint32_t len, bitIndex, wordNo;
    uint16_t word1;

    word1  = 1;

    switch(tformatDataID)
    {
        case (PM_TFORMAT_DATAID0):
        case (PM_TFORMAT_DATAID1):
        case (PM_TFORMAT_DATAID7):
        case (PM_TFORMAT_DATAID8):
        case (PM_TFORMAT_DATAIDC):

            len = 8;

            bitIndex = 13;
            wordNo = 1;
            tformatData.controlField = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.statusField = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.dataField0 = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.dataField1 = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.dataField2 = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.crc = tformat_getBits (len, wordNo, bitIndex);

            tformatData.rxPkts[0] = ((uint32_t) tformatData.controlField << 24)
                                    | ((uint32_t) tformatData.statusField << 16)
                                    | ((uint32_t) tformatData.dataField0 << 8)
                                    | ((uint32_t) tformatData.dataField1);

            tformatData.rxPkts[1] = ((uint32_t) tformatData.dataField2) ;

        break;

        case (PM_TFORMAT_DATAID2):
            len = 8;

            bitIndex = 13;
            wordNo = 1;
            tformatData.controlField = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.statusField = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.dataField0 = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.crc = tformat_getBits (len, wordNo, bitIndex);

            tformatData.rxPkts[0] = ((uint32_t) tformatData.controlField << 16)
                                    | ((uint32_t) tformatData.statusField << 8)
                                    | ((uint32_t) tformatData.dataField0);
        break;

        case (PM_TFORMAT_DATAID3):
            len = 8;
            bitIndex = 13;
            wordNo = 1;
            tformatData.controlField = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.statusField = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.dataField0 = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.dataField1 = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.dataField2 = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.dataField3 = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.dataField4 = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.dataField5 = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.dataField6 = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.dataField7 = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.crc = tformat_getBits (len, wordNo, bitIndex);

            tformatData.rxPkts[0] = ((uint32_t) tformatData.controlField << 24)
                                  | ((uint32_t) tformatData.statusField << 16)
                                  | ((uint32_t) tformatData.dataField0 << 8)
                                  | (uint32_t) tformatData.dataField1;

            tformatData.rxPkts[1] = ((uint32_t) tformatData.dataField2 << 24) |
                                    ((uint32_t) tformatData.dataField3 << 16) |
                                    ((uint32_t) tformatData.dataField4 << 8) |
                                    ((uint32_t) tformatData.dataField5);

            tformatData.rxPkts[2] = ((uint32_t) tformatData.dataField6 << 8) |
                                      ((uint32_t) tformatData.dataField7);

        break;

        case (PM_TFORMAT_DATAIDD):
            len = 8;

            bitIndex = 9;
            wordNo = 2;
            tformatData.controlField = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.eepromAddress = tformat_getBits (len,
                            wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.eepromRdDtata = tformat_getBits (len,
                            wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.crc = tformat_getBits (len, wordNo, bitIndex);

            tformatData.rxPkts[0] = ((uint32_t) tformatData.controlField << 16)
                                  | ((uint32_t) tformatData.eepromAddress << 8)
                                  | ((uint32_t) tformatData.eepromRdDtata);
        break;

        case (PM_TFORMAT_DATAID6):

            len = 8;

            bitIndex = 15;
            wordNo = 3;
            tformatData.controlField = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.eepromAddress = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.eepromRdDtata = tformat_getBits (len, wordNo, bitIndex);

            wordNo = wordNo + (10 + (16 - bitIndex) ) / 16;
            bitIndex = 16 - ((10 + (16 - bitIndex)) % 16) ;
            tformatData.crc = tformat_getBits (len, wordNo, bitIndex);

            tformatData.rxPkts[0] = ((uint32_t) tformatData.controlField << 16)
                                  | ((uint32_t) tformatData.eepromAddress << 8)
                                  | ((uint32_t) tformatData.eepromRdDtata);
            break;

    }

    return(word1);
}

uint32_t tformat_getBits (uint16_t len, uint16_t wordNo, uint16_t bitIndex)
{
    uint32_t shift0, shift1, shift2, mask0, mask1, mask2;
    uint32_t temp32;

    shift2 = (len > (16 + bitIndex) ) ? (32 - len + bitIndex): 32;
    shift1 = (len > (16 + bitIndex) ) ? (16 - shift2) : (len > bitIndex ) ?
            (16 - len + bitIndex): 32;
    shift0 = (len > (16 + bitIndex) ) ? (16 + shift1) : (len > bitIndex ) ?
            (16 - shift1): (bitIndex - len);

    mask2 = (len > (16 + bitIndex) ) ? 0xFFFFFFFF : 0;
    mask1 = (len > bitIndex ) ? 0xFFFFFFFF : 0;
    mask0 = (len > bitIndex )? ((1 << bitIndex) - 1): ((1 << len) - 1) ;

    temp32 = (len > (16 + bitIndex) ) ? (((tformatData.rdata[wordNo + 2] &
            mask2) >> shift2) | ((tformatData.rdata[wordNo + 1] & mask1)
            << shift1) | ((tformatData.rdata[wordNo] & mask0) << shift0))
            : (len > bitIndex ) ? (((tformatData.rdata[wordNo + 1] & mask1)
            >> shift1) | ((tformatData.rdata[wordNo] & mask0) << shift0))
            : ((tformatData.rdata[wordNo] >> shift0) & mask0) ;

    return(temp32);
}


void PM_tformat_setFreq(uint32_t freq_us)
{
    EALLOW;
    CLB_writeInterface(CLB4_BASE, CLB_ADDR_COUNTER_0_MATCH1, (freq_us - 1));
    CLB_writeInterface(CLB4_BASE, CLB_ADDR_COUNTER_0_MATCH2,
            ((2 * freq_us) - 1));
    CLB_setGPREG(CLB4_BASE, 0x80);
    EDIS;
}

void PM_tformat_startOperation(void)
{
    EALLOW;
    HWREG(CLB4_BASE + CLB_LOGICCTL + CLB_O_LOAD_EN) |= CLB_LOAD_EN_GLOBAL_EN
            | CLB_LOAD_EN_STOP;

    __asm(" RPT #10 || NOP");
    CLB_setOutputMask(CLB4_BASE, 0x3C, true);
    __asm(" RPT #10 || NOP");
    CLB_setGPREG(CLB4_BASE, 0x81);
}


void tformat_putBits (uint32_t data, uint16_t wordNo, uint16_t bitIndex)
{

    tformatData.sdata[wordNo] = (data >> (25 - bitIndex) )
                                & ((1L << bitIndex) - 1);
    if((25 - bitIndex) > 16)
    {
        tformatData.sdata[wordNo + 1] = (data >> (25 - bitIndex - 16) )
                                        & ((1L << 16) - 1);
        tformatData.sdata[wordNo + 2] = data &
                                        ((1 << (25 - bitIndex - 16)) - 1);
    }
    else
    {
        tformatData.sdata[wordNo + 1] = (data & ((1 << (25 - bitIndex)) - 1))
                                        << (16 - (25 - bitIndex));
    }


}

void tformat_configureSPILen(uint16_t wordLen)
{
    SPI_disableModule(PM_TFORMAT_SPI);
    SPI_enableModule(PM_TFORMAT_SPI);

    HWREGH(PM_TFORMAT_SPI + SPI_O_CCR) |= wordLen;
    HWREGH(PM_TFORMAT_SPI + SPI_O_FFRX) = (HWREGH(PM_TFORMAT_SPI + SPI_O_FFRX)
                                          & (~SPI_FFRX_RXFFIL_M))
                                          | (uint16_t)tformatData.fifoLevel;

    HWREGH(PM_TFORMAT_SPI + SPI_O_FFTX) = (HWREGH(PM_TFORMAT_SPI + SPI_O_FFTX)
                                          & (~SPI_FFTX_TXFFIL_M))
                                          | (uint16_t)tformatData.fifoLevel;


    SPI_resetTxFIFO(PM_TFORMAT_SPI);
    SPI_disableModule(PM_TFORMAT_SPI);
    SPI_enableModule(PM_TFORMAT_SPI);
}

void tformat_resetCLB(void)
{

    CLB_setGPREG(CLB4_BASE, 0);

    //
    // Turn OFF the CLB functionality
    //
    EALLOW;
    HWREG(CLB4_BASE + CLB_LOGICCTL + CLB_O_LOAD_EN) = 0;
    EDIS;

    //
    // Clear Counters - this will clear counter REGs. Add_shift_on_even_en
    // should be Zero for this to take effect.
    //
    CLB_writeInterface(CLB4_BASE, CLB_ADDR_COUNTER_0_LOAD, 0x0);
    CLB_writeInterface(CLB4_BASE, CLB_ADDR_COUNTER_1_LOAD, 0x0);
    CLB_writeInterface(CLB4_BASE, CLB_ADDR_COUNTER_2_LOAD, 0x0);

    //
    // Clear and reload the HLC registers
    //
    CLB_writeInterface(CLB4_BASE, CLB_ADDR_HLC_R0, 0x9);
    CLB_writeInterface(CLB4_BASE, CLB_ADDR_HLC_R1, 0x0);
    CLB_writeInterface(CLB4_BASE, CLB_ADDR_COUNTER_1_MATCH1, 0x2);

    CLB_setOutputMask(CLB4_BASE, 0, false);

}


void tformat_initSPIFIFO(uint32_t devLSPCLKFreq) {

//
// Initialize SPI FIFO registers
//
    SPI_disableModule(PM_TFORMAT_SPI);
    SPI_disableLoopback(PM_TFORMAT_SPI);

    SPI_setConfig(PM_TFORMAT_SPI, devLSPCLKFreq, SPI_PROT_POL1PHA0,
                SPI_MODE_SLAVE, 500000, 9);

    SPI_clearInterruptStatus(PM_TFORMAT_SPI, SPI_INT_RX_OVERRUN |
                             SPI_INT_RX_DATA_TX_EMPTY | SPI_INT_RXFF |
                             SPI_INT_RXFF_OVERFLOW | SPI_INT_TXFF);
    SPI_enableFIFO(PM_TFORMAT_SPI);
    SPI_setFIFOInterruptLevel(PM_TFORMAT_SPI, SPI_FIFO_TX3, SPI_FIFO_RX3);
    SPI_setEmulationMode(PM_TFORMAT_SPI, SPI_EMULATION_FREE_RUN);
    SPI_enableModule(PM_TFORMAT_SPI);
    SPI_resetTxFIFO(PM_TFORMAT_SPI);
    SPI_resetRxFIFO(PM_TFORMAT_SPI);

    SPI_enableInterrupt(PM_TFORMAT_SPI, SPI_INT_RX_OVERRUN |
                        SPI_INT_RX_DATA_TX_EMPTY | SPI_INT_RXFF
                        | SPI_INT_RXFF_OVERFLOW);
}

void tformat_initCLBXBAR() {

//    XBAR_setCLBMuxConfig(XBAR_AUXSIG0, XBAR_CLB_MUX01_INPUTXBAR1);
//    XBAR_enableCLBMux(XBAR_AUXSIG0, XBAR_MUX01);
//    XBAR_setOutputMuxConfig(XBAR_OUTPUT6, XBAR_OUT_MUX13_CLB4_OUT4);
//    XBAR_enableOutputMux(XBAR_OUTPUT6, XBAR_MUX13);
}

void tformat_initCLB4(void)
{
    uint16_t i;

//
// Output LUT
//
    CLB_configOutputLUT(CLB4_BASE, CLB_OUT0, TILE1_CFG_OUTLUT_0);
    CLB_configOutputLUT(CLB4_BASE, CLB_OUT1, TILE1_CFG_OUTLUT_1);
    CLB_configOutputLUT(CLB4_BASE, CLB_OUT2, TILE1_CFG_OUTLUT_2);
    CLB_configOutputLUT(CLB4_BASE, CLB_OUT3, TILE1_CFG_OUTLUT_3);
    CLB_configOutputLUT(CLB4_BASE, CLB_OUT4, TILE1_CFG_OUTLUT_4);
    CLB_configOutputLUT(CLB4_BASE, CLB_OUT5, TILE1_CFG_OUTLUT_5);
    CLB_configOutputLUT(CLB4_BASE, CLB_OUT6, TILE1_CFG_OUTLUT_6);
    CLB_configOutputLUT(CLB4_BASE, CLB_OUT7, TILE1_CFG_OUTLUT_7);

    //
    // LUT4
    //
    CLB_selectLUT4Inputs(CLB4_BASE, TILE1_CFG_LUT4_IN0, TILE1_CFG_LUT4_IN1,
                         TILE1_CFG_LUT4_IN2, TILE1_CFG_LUT4_IN3);
    CLB_configLUT4Function(CLB4_BASE, TILE1_CFG_LUT4_FN10, TILE1_CFG_LUT4_FN2);

    //
    // FSM
    //
    CLB_selectFSMInputs(CLB4_BASE, TILE1_CFG_FSM_EXT_IN0,
                        TILE1_CFG_FSM_EXT_IN1, TILE1_CFG_FSM_EXTRA_IN0,
                        TILE1_CFG_FSM_EXTRA_IN1);
    CLB_configFSMNextState(CLB4_BASE, TILE1_CFG_FSM_NEXT_STATE_0,
                           TILE1_CFG_FSM_NEXT_STATE_1,
                           TILE1_CFG_FSM_NEXT_STATE_2);
    CLB_configFSMLUTFunction(CLB4_BASE, TILE1_CFG_FSM_LUT_FN10,
                             TILE1_CFG_FSM_LUT_FN2);

    //
    // Counters
    //
    CLB_selectCounterInputs(CLB4_BASE, TILE1_CFG_COUNTER_RESET,
                            TILE1_CFG_COUNTER_EVENT, TILE1_CFG_COUNTER_MODE_0,
                            TILE1_CFG_COUNTER_MODE_1);
    CLB_configMiscCtrlModes(CLB4_BASE, TILE1_CFG_MISC_CONTROL);
    CLB_configCounterLoadMatch(CLB4_BASE, CLB_CTR0, TILE1_COUNTER_0_LOAD_VAL,
                               TILE1_COUNTER_0_MATCH1_VAL,
                               TILE1_COUNTER_0_MATCH2_VAL);
    CLB_configCounterLoadMatch(CLB4_BASE, CLB_CTR1, TILE1_COUNTER_1_LOAD_VAL,
                               TILE1_COUNTER_1_MATCH1_VAL,
                               TILE1_COUNTER_1_MATCH2_VAL);
    CLB_configCounterLoadMatch(CLB4_BASE, CLB_CTR2, TILE1_COUNTER_2_LOAD_VAL,
                               TILE1_COUNTER_2_MATCH1_VAL,
                               TILE1_COUNTER_2_MATCH2_VAL);

    //
    // HLC
    //
    CLB_configHLCEventSelect(CLB4_BASE, TILE1_HLC_EVENT_SEL);
    CLB_setHLCRegisters(CLB4_BASE, TILE1_HLC_R0_INIT, TILE1_HLC_R1_INIT,
                        TILE1_HLC_R2_INIT, TILE1_HLC_R3_INIT);

    for(i = 0; i <= CLB_NUM_HLC_INSTR; i++)
    {
        CLB_programHLCInstruction(CLB4_BASE, i, tformat_tile1HLCInstr[i]);
    }
}

tformat.c

//-----------------------------------------------------------------------------
//  FILE:           tformat.c
//
//  Description:    Contains all the initialization, data declarations
//                  and setup for tformat encoder interface.
//                  This file serves are a template for using PM_tformat
//                  Library to interface and incorporates all the encoder
//                  and library specific initializations and other important
//                  aspects of usage.
//
//  Version:        1.0
//
//  Target:         TMS320F28377D,
//
//-----------------------------------------------------------------------------
//  Copyright Texas Instruments 锟� 2004-2015
//-----------------------------------------------------------------------------
//  Revision History:
//-----------------------------------------------------------------------------
//  Date      | Description / Status
//-----------------------------------------------------------------------------
// Feb 2019  - Example project for PM tformat Library Usage
//-----------------------------------------------------------------------------

#include "tformat.h"

uint16_t tformatCRCtable[PM_TFORMAT_CRCTABLE_SIZE];  //table - CRC calculations

PM_tformat_DataStruct tformatData;        //PM tformat data structure

//
// Function to initialize tformat operation
//
void tformat_init(void) {

    SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_EPWM4);
//    SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_EPWM1);//r

    //
    //Configure EPWM4 to drive default values on GPIO1
    //
    tformat_configEPWM4();
    //tformat_configEPWM1();//r

    //
    // Generate table for tformat Polynomial defied as POLY1
    //
    PM_tformat_generateCRCTable(PM_TFORMAT_NBITS_POLY1, PM_TFORMAT_POLY1, tformatCRCtable);

    //
    //GPIO configuration for tformat operation
    //
    tformat_setupGPIO();

    //
    //XBAR configuration for tformat operation
    //
    tformat_configXBAR();

    PM_tformat_setupPeriph(DEVICE_LSPCLK_FREQ);

    //
    // Must put SPI into reset before configuring it
    //
    SPI_disableModule(SPIA_BASE);
    SPI_disableInterrupt(SPIA_BASE, SPI_INT_RXFF);

    //
    // FIFO and interrupt configuration
    //
    SPI_clearInterruptStatus(SPIA_BASE, SPI_INT_RXFF);
    SPI_enableInterrupt(SPIA_BASE, SPI_INT_RXFF);

    //
    // Configuration complete. Enable the module.
    //
    SPI_enableModule(SPIA_BASE);

    //
    // Power up tformat 5v supply through GPIO139
    //
    GPIO_writePin(13, 1);//r
    SysCtl_delay(2000000L);
    PM_tformat_setFreq(TFORMAT_FREQ_DIVIDER);
}

void tformat_setupGPIO(void) {

    //
    // GPIO7 is SPI Clk slave
    //r
    GPIO_setMasterCore(7, GPIO_CORE_CPU1);
    GPIO_setPinConfig(GPIO_7_EPWM4_B);

    //
    // GPIO16 is the SPISIMOA
    //r
    GPIO_setMasterCore(16, GPIO_CORE_CPU1);
    GPIO_setPinConfig(GPIO_16_SPIA_SIMO);
    GPIO_setQualificationMode(16, GPIO_QUAL_ASYNC);

    //
    // GPIO17 is the SPISOMIA
    //r
    GPIO_setMasterCore(17, GPIO_CORE_CPU1);
    GPIO_setPinConfig(GPIO_17_SPIA_SOMI);
    GPIO_setQualificationMode(17, GPIO_QUAL_ASYNC);

    //
    // GPIO56 is the SPICLKA
    //r
    GPIO_setMasterCore(56, GPIO_CORE_CPU1);
    GPIO_setPinConfig(GPIO_56_SPIA_CLK);
    GPIO_setQualificationMode(56, GPIO_QUAL_ASYNC);

    //
    // GPIO57 is the SPISTEA
    //r
    GPIO_setMasterCore(57, GPIO_CORE_CPU1);
    GPIO_setPinConfig(GPIO_57_SPIA_STE);
    GPIO_setQualificationMode(57, GPIO_QUAL_ASYNC);

    //
    // GPIO9 is tformat TxEN
    //r
    GPIO_setMasterCore(9, GPIO_CORE_CPU1);
    GPIO_setPinConfig(GPIO_9_OUTPUTXBAR6);



    //
    // GPIO13 is PwrEN
    //r
    GPIO_setMasterCore(13, GPIO_CORE_CPU1);
    GPIO_setDirectionMode(13, GPIO_DIR_MODE_OUT);
}

void tformat_configXBAR(void)
{
    //
    // Connect InputXbar-INPUT1 to GPIO16 - SPISIMO
    //

    XBAR_setInputPin(XBAR_INPUT1, 16);//r

    XBAR_setCLBMuxConfig(XBAR_AUXSIG0, XBAR_CLB_MUX01_INPUTXBAR1);//InputXbar-INPUT1 TO XBAR_CLB_MUX01
    XBAR_enableCLBMux(XBAR_AUXSIG0, XBAR_MUX01);
    XBAR_setOutputMuxConfig(XBAR_OUTPUT6, XBAR_OUT_MUX13_CLB4_OUT4);
    XBAR_enableOutputMux(XBAR_OUTPUT6, XBAR_MUX13);

}


void tformat_error(void) {
    ESTOP0;     //Test failed!! Stop!
    for (;;);
}

interrupt void spiRxFIFOISR(void)
{
    uint16_t i;
    for (i = 0;i <= tformatData.fifoLevel;i++)
    {
        tformatData.rdata[i] = SPI_readDataNonBlocking(PM_TFORMAT_SPI);
    }
    SPI_clearInterruptStatus(PM_TFORMAT_SPI, SPI_INT_RXFF_OVERFLOW);
    SPI_clearInterruptStatus(PM_TFORMAT_SPI, SPI_INT_RXFF);
    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP6);
    tformatData.dataReady = 1;
}


void tformat_configEPWM4(void) {

    //
    // Set the PWMA and B high as default values of tformat clk.
    // Action on TZ1
    //
    EPWM_setTripZoneAction(EPWM4_BASE,
                           EPWM_TZ_ACTION_EVENT_TZA,
                           EPWM_TZ_ACTION_HIGH);


    //
    // Action on TZ1
    //
    EPWM_setTripZoneAction(EPWM4_BASE,
                           EPWM_TZ_ACTION_EVENT_TZB,
                           EPWM_TZ_ACTION_HIGH);

    //
    // Forces a Trip Zone event
    //
    EPWM_forceTripZoneEvent(EPWM4_BASE, EPWM_TZ_FORCE_EVENT_OST);
}



//r
/*
void tformat_configEPWM1(void) {

    //
    // Set the PWMA and B high as default values of tformat clk.
    // Action on TZ1
    //
    EPWM_setTripZoneAction(EPWM1_BASE,
                           EPWM_TZ_ACTION_EVENT_TZA,
                           EPWM_TZ_ACTION_HIGH);


    //
    // Action on TZ1
    //
    EPWM_setTripZoneAction(EPWM1_BASE,
                           EPWM_TZ_ACTION_EVENT_TZB,
                           EPWM_TZ_ACTION_HIGH);

    //
    // Forces a Trip Zone event
    //
    EPWM_forceTripZoneEvent(EPWM1_BASE, EPWM_TZ_FORCE_EVENT_OST);
}
*/
uint16_t tformat_checkCRC (uint16_t expectCRC5, uint16_t receiveCRC5) {
    if(expectCRC5 == receiveCRC5) {
        return(1);
    }
    else {
        return(0);
    }
}

//
//This function executes all the tformat commands by calling the tformat
//library functions with different IDs.
//This is an optional function that can be used as a sanity checker
//This function is of no relevance during runtime
//At the end of each command execution CRC is also checked.
//

uint16_t tformat_exCommands(void)
{

    uint16_t retval1; //used for function return val storage and checks
    uint32_t address, address_tmp, data, data_tmp;
    uint32_t crcResult;

    retval1 = PM_tformat_setupCommand (PM_TFORMAT_DATAID2, 0, 0, 0);
    PM_tformat_startOperation();
    while(tformatData.dataReady != 1) ;//{;}
    retval1 = PM_tformat_receiveData(PM_TFORMAT_DATAID2);

    crcResult = PM_tformat_getCRC(0, 24, 8, (uint16_t *)&tformatData.rxPkts,
                                  tformatCRCtable, 3);
    crcResult = crcResult ^ (0xFF);
     if(!tformat_checkCRC(crcResult, tformatData.crc))
     {
             ESTOP0;
     }

    SysCtl_delay(40000L); //DELAY_US(400L);
    retval1 = PM_tformat_setupCommand (PM_TFORMAT_DATAID0, 0, 0, 0);
    PM_tformat_startOperation();
    while(tformatData.dataReady != 1) {}
    retval1 = PM_tformat_receiveData(PM_TFORMAT_DATAID0);

    crcResult = PM_tformat_getCRC(0, 40, 8, (uint16_t *)&tformatData.rxPkts,
                                  tformatCRCtable, 5);

    crcResult = crcResult ^ (0xFF);
     if(!tformat_checkCRC(crcResult, tformatData.crc))
     {
             ESTOP0;
     }

    SysCtl_delay(40000L); //DELAY_US(400L);
    retval1 = PM_tformat_setupCommand (PM_TFORMAT_DATAID1, 0, 0, 0);
    PM_tformat_startOperation();
    while(tformatData.dataReady != 1) {}
    retval1 = PM_tformat_receiveData(PM_TFORMAT_DATAID1);

    crcResult = PM_tformat_getCRC(0, 40, 8, (uint16_t *)&tformatData.rxPkts,
                                  tformatCRCtable, 5);
    crcResult = crcResult ^ (0xFF);
     if(!tformat_checkCRC(crcResult, tformatData.crc))
     {
             ESTOP0;
     }

    SysCtl_delay(40000L); //DELAY_US(400L);
    address = 1;
    address_tmp = (__flip32(address) >> 24) & 0xFE; // includes busy "0"
    tformatData.rxPkts[0] = ((((uint32_t) PM_TFORMAT_DATAIDD) | 0x40) << 8) |
                            (uint32_t) address_tmp;
    crcResult = PM_tformat_getCRC(0, 16, 8, (uint16_t *)&tformatData.rxPkts,
                                  tformatCRCtable, 2);
    crcResult = (crcResult) ^ (0xFF);

    retval1 = PM_tformat_setupCommand (PM_TFORMAT_DATAIDD, address, 0, crcResult);
    PM_tformat_startOperation();
    while(tformatData.dataReady != 1) {}
    retval1 = PM_tformat_receiveData(PM_TFORMAT_DATAIDD);

    crcResult = PM_tformat_getCRC(0, 32, 8, (uint16_t *)&tformatData.rxPkts,
                                  tformatCRCtable, 4);
    crcResult = crcResult ^ (0xFF);
     if(!tformat_checkCRC(crcResult, tformatData.crc))
     {
             ESTOP0;
     }

    SysCtl_delay(40000L); //DELAY_US(400L);
    address = 1; data = 35;
    address_tmp = (__flip32(address) >> 24) & 0xFE; // includes busy "0"
    data_tmp = (__flip32(data) >> 24) & 0xFF;
    tformatData.rxPkts[0] = ((((uint32_t) PM_TFORMAT_DATAID6) | 0x40) << 16) |
                            (((uint32_t) address_tmp) << 8) |
                            ((uint32_t) data_tmp);
    crcResult = PM_tformat_getCRC(0, 24, 8, (uint16_t *)&tformatData.rxPkts,
                                  tformatCRCtable, 3);
    crcResult = (crcResult) ^ (0xFF);

    retval1 = PM_tformat_setupCommand (PM_TFORMAT_DATAID6, address, data, crcResult);
    PM_tformat_startOperation();
    while(tformatData.dataReady != 1) {}
    retval1 = PM_tformat_receiveData(PM_TFORMAT_DATAID6);

    crcResult = PM_tformat_getCRC(0, 32, 8, (uint16_t *)&tformatData.rxPkts,
                                  tformatCRCtable, 4);
    crcResult = crcResult ^ (0xFF);
     if(!tformat_checkCRC(crcResult, tformatData.crc))
     {
             ESTOP0;
     }

    SysCtl_delay(40000L); //DELAY_US(400L);
    address = 1;
    address_tmp = (__flip32(address) >> 24) & 0xFE; // includes busy "0"
    tformatData.rxPkts[0] = ((((uint32_t) PM_TFORMAT_DATAIDD) | 0x40) << 8) |
                            (uint32_t) address_tmp;
    crcResult = PM_tformat_getCRC(0, 16, 8, (uint16_t *)&tformatData.rxPkts,
                                  tformatCRCtable, 2);
    crcResult = (crcResult) ^ (0xFF);

    retval1 = PM_tformat_setupCommand (PM_TFORMAT_DATAIDD, address, 0, crcResult);
    PM_tformat_startOperation();
    while(tformatData.dataReady != 1) {}
    retval1 = PM_tformat_receiveData(PM_TFORMAT_DATAIDD);

    crcResult = PM_tformat_getCRC(0, 32, 8, (uint16_t *)&tformatData.rxPkts,
                                  tformatCRCtable, 4);
    crcResult = crcResult ^ (0xFF);
     if(!tformat_checkCRC(crcResult, tformatData.crc))
     {
             ESTOP0;
     }
     SysCtl_delay(4000L);
     return(retval1);

}

//
// End of file
//

+1 Lori Heustess over 1 year ago in reply to ren ken

TI__Guru* 89465 points

Hello,

ren ken said:
it runs well in my launchxl-f280049c,

If I understand your issue is resolved? If so please confirm by pressing the "resolved" button. If you still need some help, leave me some details on what is not working correctly and what you have tried to resolve it.

Thank you

Lori

0 ren ken over 1 year ago in reply to Lori Heustess

Prodigy 20 points

my encoder is TS5700N8502 , which is tidue74c reference to . communication process is successful. but it is not utility because that it did not start implement communication until I give a pulse signal into SPI-SIMO mannually. I am looking for a way to implement communication automatically.

0 Lori Heustess over 1 year ago in reply to ren ken

TI__Guru* 89465 points

You should not have to put a pulse on SIMO. The SPI SIMO pin connects to the data coming into the MCU. This is the response from the encoder. After the encoder sees the request it will respond. If it fails to respond then check the clock into the SPI. The frequency should be 2.5 MHz. If the frequency is not 2.5Mhz then the encoder will not respond.

Is there a clock signal on the correct SPI CLOCK pin? Is it 2.5MHz?

Does the request go out of the device on the SPI SOMI pin?

0 ren ken over 1 year ago in reply to Lori Heustess

Prodigy 20 points

Thank you, Lori.

I'm coming back from vacation.

it is the SOMI signal that my wave different to your .

0 ren ken over 1 year ago in reply to ren ken

Prodigy 20 points

I start running , it stay at " while(tformatData.dataReady != 1)" , then I full halt , and restart , it can communicates. I am finding out my mistake.

0 Lori Heustess over 1 year ago in reply to ren ken

TI__Guru* 89465 points

Thank you for an update, Ren. I am interested in hearing what you find.

Regards

Lori

+1 ren ken over 1 year ago in reply to Lori Heustess

Prodigy 20 points

after tformat initialization, I add latency . now , it is ok for communication.

tformat_init();

DEVICE_DELAY_US(80000L); modify 800 to 80000.

C2000™︎ microcontrollers

C2000 microcontrollers forum

TMS320F280049C: LAUNCHXL-F280049C+BOOSTXL-POSMGR+TFORMAT can't work