TMS320F280049C: LIN module in slave mode - how to initiate response transmission

Hi John,

As an update, I have spent quite a bit of time trying to figure out what is missing in the code provided, and cannot seem to find the root cause. I am currently working in the opposite direction now to try and debug this: I am starting with a working example and trying to move it closer to your example and finding what breaks it.

I expect to have some more details soon, but I am reaching out to other team members to see what other settings could block slave response frame.

Please expect another update by late week.

Regards,

Vince

Hi John,

Here is an example for the LIN slave mode. This walks through the configuration bits needed for LIN slave mode. Some comments may be incorrect, and note that the interrupt functions are not actually used (this is polling). I have not tested this on F28004x, but this should provide all necessary steps to get slave mode operations working.

//
// Included Files
//
#include "driverlib.h"
#include "device.h"

//
// Defines
//
#define FRAME_LENGTH    0x8
#define LIN_PASS        0xABCD
#define LIN_FAIL        0xFFFF

//
// Globals
//
volatile uint32_t level0Count = 0;
volatile uint32_t level1Count = 0;
volatile uint32_t vectorOffset = 0;
uint16_t result;
uint16_t txData[8] = {0x11, 0x34, 0x56, 0x78, 0x9A, 0xAB, 0xCD, 0xEF};
uint16_t rxData[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
uint32_t i, dataIndex, sciflr;
uint16_t txID, error;

//
// Function Prototypes
//
__interrupt void level0ISR(void);
__interrupt void level1ISR(void);
static void MainLoop(void);

//
// Main
//
void main(void)
{
    //
    // Initialize device clock and peripherals
    //
    Device_init();

    //
    // Initialize GPIO and configure GPIO pins for LINTX/LINRX
    //
    Device_initGPIO();
    GPIO_setPinConfig(GPIO_28_LINTXA);

    GPIO_setPinConfig(GPIO_29_LINRXA);


    GPIO_setPinConfig(GPIO_16_XCLKOUT);
    GPIO_setPadConfig(39, GPIO_PIN_TYPE_PULLUP);     // Enable pullup on GPIO39
    GPIO_writePin(39, 1);                            // Load output latch
    GPIO_setPinConfig(GPIO_39_GPIO39);                // GPIO39 = GPIO39
    GPIO_setDirectionMode(39, GPIO_DIR_MODE_OUT);    // GPIO39 = output

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

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

    EINT;
    ERTM;

    //
    // Check the arguments.
    //
    ASSERT(LIN_isBaseValid(LINA_BASE));

    EALLOW;

    //
    // Reset LIN module
    // Release from hard reset
    //
    LIN_disableModule(LINA_BASE);
    LIN_enableModule(LINA_BASE);

    //
    // Enter Software Reset State
    //
    LIN_enterSoftwareReset(LINA_BASE);

    //
    // Enable LIN Mode
    //
    LIN_disableSCIMode(LINA_BASE);

    //
    // Set LIN mode to Master
    //
    LIN_setLINMode(LINA_BASE, LIN_MODE_LIN_SLAVE);

    //
    // Enable Fixed baud rate mode
    //
    LIN_disableAutomaticBaudrate(LINA_BASE);

    //
    // Use the set frame length and not ID4/ID5 bits for length control
    //
    LIN_setCommMode(LINA_BASE, LIN_COMM_LIN_USELENGTHVAL);

    //
    // Setup to continue operating on emulation suspend
    //
    LIN_setDebugSuspendMode(LINA_BASE, LIN_DEBUG_COMPLETE);

    //
    // Use Enhanced Checksum
    //
    LIN_setChecksumType(LINA_BASE, LIN_CHECKSUM_ENHANCED);

    //
    // Message filtering uses slave task ID byte
    //
    LIN_setMessageFiltering(LINA_BASE, LIN_MSG_FILTER_IDSLAVE);

    //
    // Disable Internal loopback for external communication
    //
    LIN_disableIntLoopback(LINA_BASE);

    //
    // Enable multi-buffer mode
    //
    LIN_enableMultibufferMode(LINA_BASE);

    //
    // Enable parity check on received ID
    //
    LIN_enableParity(LINA_BASE);

    //
    // Enable transfer of data to and from the shift registers
    //
    LIN_enableDataTransmitter(LINA_BASE);
    LIN_enableDataReceiver(LINA_BASE);

    //
    // Enable the triggering of checksum compare on extended frames
    //
    LIN_triggerChecksumCompare(LINA_BASE);

    LIN_sendChecksum(LINA_BASE); // send checksum
    //
    // Set LIN interrupts to disabled
    //
    LIN_disableInterrupt(LINA_BASE, LIN_INT_ALL);

    //
    // Set Baud Rate Settings - 100MHz Device
    //
    LIN_setBaudRatePrescaler(LINA_BASE, 599U, 0U);    
    LIN_setMaximumBaudRate(LINA_BASE, 100000000U);

    //
    // Set response field to 1 byte
    //
    //LIN_setFrameLength(base, 1U);
    LIN_setFrameLength(LINA_BASE, 8U);

    //
    // Configure sync field
    // Sync break (13 + 5 = 18 Tbits)
    // Sync delimiter (1 + 3 = 4 Tbits)
    //
    LIN_setSyncFields(LINA_BASE, 0U, 1U);

    //
    // Set Mask ID so TX/RX match will always happen
    //
    LIN_setTxMask(LINA_BASE, 0x83U);
    LIN_setRxMask(LINA_BASE, 0xC3U);

    //
    // Disable IODFT testing and external loopback mode
    //
    LIN_disableExtLoopback(LINA_BASE);

    //
    // Finally exit SW reset and enter LIN ready state
    //
    LIN_exitSoftwareReset(LINA_BASE);

    LIN_setIDSlaveTask(LINA_BASE, 0xE8 );
    EDIS;


    while(1)
    {
        MainLoop();
    }
}

#pragma CODE_SECTION(MainLoop, ".TI.ramfunc");
static void MainLoop(void)
{


    // Wait for RX ID or TX ID match
    while(!(LIN_isRxMatch(LINA_BASE) || LIN_isTxMatch(LINA_BASE)));

    if (LIN_isRxMatch(LINA_BASE))
    {
        // Wait for RX Ready flag
        while(!LIN_isRxReady(LINA_BASE));
        //
        // Read the received data in the receive buffers
        //
        LIN_getData(LINA_BASE, rxData);
    }

    if (LIN_isTxMatch(LINA_BASE))
    {
        //SysCtl_delay(500000);
        // Wait for TX Ready
        while(!LIN_isTxReady(LINA_BASE));
        // Send TX Data
        LIN_sendData(LINA_BASE, txData);
        //
        // Wait until Transmit buffer is empty and has completed transmission
        //
        while(!LIN_isTxBufferEmpty(LINA_BASE));
    }

    HWREG(LINA_BASE + LIN_O_SCIFLR) = 0x6000; // clear RXIDFLG and TXIDFLG

}

//
// LIN High Priority (Level 0) ISR - Interrupt service routine for interrupt
// line 0. This ISR saves the offset vector indicating the current highest
// priority pending interrupt.
//
__interrupt void
level0ISR(void)
{
    //
    // Increment the interrupt count
    //
    level0Count++;

    //
    // Read the high priority interrupt vector
    //
    vectorOffset = LIN_getInterruptLine0Offset(LINA_BASE);
    LIN_clearInterruptStatus(LINA_BASE, LIN_INT_ID);
    LIN_clearGlobalInterruptStatus(LINA_BASE, LIN_INTERRUPT_LINE0);

    //
    // Acknowledge this interrupt located in group 8
    //
    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP8);
}

//
// LIN Low Priority (Level 1) ISR - Interrupt service routine for interrupt
// line 1. This ISR saves the offset vector indicating the current highest
// priority pending interrupt.
//
__interrupt void
level1ISR(void)
{
    //
    // Increment the interrupt count
    //
    level1Count++;

    //
    // Read the low priority interrupt vector
    //
    vectorOffset = LIN_getInterruptLine1Offset(LINA_BASE);
    LIN_clearInterruptStatus(LINA_BASE, LIN_INT_ID);
    LIN_clearGlobalInterruptStatus(LINA_BASE, LIN_INTERRUPT_LINE1);

    //
    // Acknowledge this interrupt located in group 8
    //
    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP8);
}

Let me know if any questions/concerns with this code.

Regards,

Vince

Hello Vince,

I was able to get back to this issue today. Yuhoo! Now it is working. Thanks for the example. That really helped a lot.

The only thing I changed in my code, was to move the code in the indefinite loop into the RAM section.These were the key lines that helped:

    while (1)
    {
        MainLoop();
    }//for / while
    
    and 
    
    
#pragma CODE_SECTION(MainLoop, ".TI.ramfunc");
static void MainLoop(void)
{
   ... moved the code from the while(1) loop to here.
   }

Then everything just starting working. Wow.

Thanks again. Your sample code helped me a lot!

Cheers,

John