[参考译文] TMS320F28388D：为 TMS320F28388D 控制卡配置 SPIA 寄存器时出现问题

admin

Other Parts Discussed in Thread: TMS320F28388D, TMS320F28377D, C2000WARE

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

https://e2e.ti.com/support/microcontrollers/c2000-microcontrollers-group/c2000/f/c2000-microcontrollers-forum/1073282/tms320f28388d-issue-in-configuring-spia-registers-for-tms320f28388d-control-card

部件号：TMS320F28388D
“线程”中讨论的其它部件： TMS320F28377D， C2000WARE，测试

您好，

我们通过 SPI 将 TMMC5130A 电机驱动器 IC 与 TMS320F28388D 和 TMS320F28377D 控制器卡连接，以旋转步进电机。

我们已经完成了如下所述的 TMC5130A 驱动 IC 数据表中所述的 SPI 配置

SPI 模式：3.

时钟速度：1MHz

SPI 字长度：8.

在数据传输过程中，芯片选择将变得较低

SPI A：GPIO16 -错误

GPIO17 - MOSI

GPIO18 - CLK

GPIO20 - CSN

我们能够看到控制器的 MOSI 线路上的数据。

但当 TMS320F28377D 控制器与 TMS320F28388D 不匹配时，电机正在旋转，即使我们已将相同的代码从控制套件迁移到 C2000。

最初，我们尝试使用 C2000器件中提供的内置 API 配置 SPI，但随后根据示例代码 SPI_ex1_loopback 更改为直接寄存器设置。

TMS320F28377D 的 SPI 代码：

Void InitSpiaGpio() //设置 SPIA GPIO 寄存器
｛

EALLOW；

/*为所选引脚启用内部上拉*/
//用户可以启用或禁用提取。
//这将启用指定引脚的上拉。
//注释掉其他不需要的行。

GpioCtrlRegs.GPAPUD.bit.GPIO16 = 0；//启用 GPIO16上的下拉功能(SPISIMOA)
// GpioCtrlRegs.GPAPUD.bit.GPIO5 =0；//启用 GPIO5上的下拉功能(SPISIMOA)
GpioCtrlRegs.GPAPUD.bit.GPIO17 = 0；//启用 GPIO17 (SPISOMIA)上的下拉功能
// GpioCtrlRegs.GPAPUD.bit.GPIO3 = 0；//启用 GPIO3上的下拉功能(SPISOMA)
GpioCtrlRegs.GPAPUD.bit.GPIO18 = 0；//在 GPIO18上启用上拉(SPICLKA)
GpioCtrlRegs.GPAPUD.bit.GPIO19 = 0；//启用 GPIO19上的下拉功能(SPISTEA)

/*将选定引脚的限定条件设置为仅限异步*/
//这将为选定的 PIN 选择异步(无限定条件)。
//注释掉其他不需要的行。

GpioCtrlRegs.GPAQSEL2.bit.GPIO16 = 3；//异步输入 GPIO16 (SPISIMOA)
// GpioCtrlRegs.GPAQSEL1.bit.GPIO5 =3；// asynch 输入 GPIO5 (SPISIMOA)
GpioCtrlRegs.GPAQSEL2.bit.GPIO17 = 3；//异步输入 GPIO17 (SPISOMIA)
// GpioCtrlRegs.GPAQSEL1.bit.GPIO3 = 3；// asynch 输入 GPIO3 (SPISOMIA)
GpioCtrlRegs.GPAQSEL2.bit.GPIO18 = 3；//异步输入 GPIO18 (SPICLKA)
GpioCtrlRegs.GPAQSEL2.bit.GPIO19 = 3；//异步输入 GPIO19 (SPISTEA)

/*使用 GPIO regs*/配置 SPI-A 引脚
//这指定了哪些可能的 GPIO 引脚将是 SPI 功能引脚。
//注释掉其他不需要的行。

GpioCtrlRegs.GPAMUX2.bit.GPIO16 =1；//将 GPIO16配置为 SPISIMOA
// GpioCtrlRegs.GPAMUX1.bit.GPIO5 =2；//将 GPIO5配置为 SPISIMOA
GpioCtrlRegs.GPAMUX2.bit.GPIO17 =1；//将 GPIO17配置为 SPISOMIA
// GpioCtrlRegs.GPAMUX1.bit.GPIO3 =2；//将 GPIO3配置为 SPISOMIA
GpioCtrlRegs.GPAMUX2.bit.GPIO18 = 1；//将 GPIO18配置为 SPICLKA
GpioCtrlRegs.GPAMUX2.bit.GPIO19 =1；//将 GPIO19配置为 SPISTEA

EDIS；
}

void SPI_fifo_init()
｛
//初始化 SPI FIFO 寄存器
SpiaRegs.SPIFFTX.All=0xE040；
SpiaRegs.SPIFFRX.All=0x2044;
SpiaRegs.SPIFFCT.All=0x0；
}

void SPI_INIT() 此函数将 SPI 初始化到已知状态
｛

//配置更改前将重置设置为低
//时钟极性(0 ==上升，1 ==下降)
//8位字符
// 禁用回环
SpiaRegs.SPICCR.bit.SPISWRESET = 0；
SpiaRegs.SPICCR.bit.CLKPOLARITY = 0；
SpiaRegs.SPICCR.bit.SPICHAR = 7；//8位
SpiaRegs.SPICCR.bit.SPILBK = 0；

//启用主中继器(0 ==从中继器，1 ==主中继器)
//启用传输(通话)
//时钟相位(0 =正常，1 =延迟)
// SPI 中断被禁用
SpiaRegs.SPICTL.bit.master_slave = 1；
SpiaRegs.SPICTL.bit.Talk = 1；
SpiaRegs.SPICTL.Bit.CLK_PHASE = 0；
SpiaRegs.SPICTL.Bit.SPIINTENA = 0；

//设置波特率
SpiaRegs.SPIBRR.Bit.SPI_bit_rate = 0x31；//1 MHz

//设置可用位
//在断点处停止不会停止 SPI
SpiaRegs.SPIPRI.Bit.free = 1；

//从重置中释放 SPI
SpiaRegs.SPICCR.Bit.SPISWRESET =1；
}

TMS320F28388D 的 SPI 代码：

使 SPI_GPIO 失效(无效)
｛
EALLOW；

/*为所选引脚启用内部上拉*/
//用户可以启用或禁用提取。
//这将启用指定引脚的上拉。
//注释掉其他不需要的行。

GpioCtrlRegs.GPAPUD.bit.GPIO16 = 0；//启用 GPIO16上的下拉功能(SPISIMOA)
GpioCtrlRegs.GPAPUD.bit.GPIO17 = 0；//启用 GPIO17 (SPISOMIA)上的下拉功能
GpioCtrlRegs.GPAPUD.bit.GPIO18 = 0；//在 GPIO18上启用上拉(SPICLKA)
GpioCtrlRegs.GPAPUD.bit.GPIO19 = 0；//启用 GPIO19上的下拉功能(SPISTEA)

/*将选定引脚的限定条件设置为仅限异步*/
//这将为选定的 PIN 选择异步(无限定条件)。
//注释掉其他不需要的行。

GpioCtrlRegs.GPAQSEL2.bit.GPIO16 = 3；//异步输入 GPIO16 (SPISIMOA)
GpioCtrlRegs.GPAQSEL2.bit.GPIO17 = 3；//异步输入 GPIO17 (SPISOMIA)
GpioCtrlRegs.GPAQSEL2.bit.GPIO18 = 3；//异步输入 GPIO18 (SPICLKA)
GpioCtrlRegs.GPAQSEL2.bit.GPIO19 = 3；//异步输入 GPIO19 (SPISTEA)

/*使用 GPIO regs*/配置 SPI-A 引脚
//这指定了哪些可能的 GPIO 引脚将是 SPI 功能引脚。
//注释掉其他不需要的行。

GpioCtrlRegs.GPAMUX2.bit.GPIO16 =1；//将 GPIO16配置为 SPISIMOA
GpioCtrlRegs.GPAMUX2.bit.GPIO17 =1；//将 GPIO17配置为 SPISOMIA
GpioCtrlRegs.GPAMUX2.bit.GPIO18 = 1；//将 GPIO18配置为 SPICLKA
GpioCtrlRegs.GPAMUX2.bit.GPIO19 =1；//将 GPIO19配置为 SPISTEA

EDIS；
}

inittid initSPIFO(void)
｛
//
//初始化 SPI FIFO 寄存器
//
SpiaRegs.SPIFFTX.ALL = 0xE040；
SpiaRegs.SPIFFRX.ALL = 0x2044；
SpiaRegs.SPIFFCT.ALL = 0x0；

//
//初始化核心 SPI 寄存器
//
InitSpi()；
}

//
// InitSPI -此函数将 SPI 初始化到已知状态
//
无效 InitSpi (void)
｛
//
//初始化 SPI-A
//

//
//配置更改前将重置设置为低
//时钟极性(0 ==上升，1 ==下降)
//8位字符
// 禁用回环
//
SpiaRegs.SPICCR.bit.SPISWRESET = 0；
SpiaRegs.SPICCR.bit.CLKPOLARITY = 0；
SpiaRegs.SPICCR.Bit.SPICHAR =7；
SpiaRegs.SPICCR.bit.SPILBK = 0；

//
//启用主中继器(0 ==从中继器，1 ==主中继器)
//启用传输(通话)
//时钟相位(0 =正常，1 =延迟)
// SPI 中断被禁用
//
SpiaRegs.SPICTL.bit.master_slave = 1；
SpiaRegs.SPICTL.bit.Talk = 1；
SpiaRegs.SPICTL.Bit.CLK_PHASE = 0；
SpiaRegs.SPICTL.Bit.SPIINTENA = 0；

//
//使用1 MHz SPICLK 设置波特率
// BRR =(LSPCLK / SPICLK)- 1.
//
SpiaRegs.SPIBRR.Bit.SPI_bit_rate = 0x31；

//设置可用位
//在断点处停止不会停止 SPI
//
SpiaRegs.SPIPRI.Bit.free = 1；

//
//从重置中释放 SPI
//
SpiaRegs.SPICCR.Bit.SPISWRESET =1；
}

在从 TMS320F28377D 迁移到 TMS320F28377D 时，我们是否需要考虑有关 SPIA 配置的任何更改？

TMS320F28377D 的代码如下

//###########################################################################
// FILE:   Example_2837xDSpi_FFDLB.c
// TITLE:  SPI Digital Loop Back program.
//
//! \addtogroup cpu01_example_list
//! <h1>SPI Digital Loop Back (spi_loopback)</h1>
//!
//!  This program uses the internal loop back test mode of the peripheral.
//!  Other then boot mode pin configuration, no other hardware configuration
//!  is required. Interrupts are not used.
//!
//!  A stream of data is sent and then compared to the received stream.
//!  The sent data looks like this: \n
//!  0000 0001 0002 0003 0004 0005 0006 0007 .... FFFE FFFF \n
//!  This pattern is repeated forever.
//!
//!  \b Watch \b Variables \n
//!  - \b sdata - sent data
//!  - \b rdata - received data
//
//###########################################################################
// $TI Release: F2837xD Support Library v190 $
// $Release Date: Mon Feb  1 16:51:57 CST 2016 $
// $Copyright: Copyright (C) 2013-2016 Texas Instruments Incorporated -
//             http://www.ti.com/ ALL RIGHTS RESERVED $
//###########################################################################

#include "F28x_Project.h"     // Device Headerfile and Examples Include File
#include "stdio.h"
// Prototype statements for functions found within this file.
// __interrupt void ISRTimer2(void);
void delay_loop(void);
void spi_xmit(Uint16 a);
void spi_fifo_init(void);
void spi_init(void);
void error(void);
void sendDataToDriver(Uint16 address, Uint32 sdata);
void main(void)
{
    //Uint8  addres;
    Uint32 sdata;  // send data


// Step 1. Initialize System Control:
// PLL, WatchDog, enable Peripheral Clocks
// This example function is found in the F2837xD_SysCtrl.c file.
   InitSysCtrl();

// Step 2. Initialize GPIO:
// This example function is found in the F2837xD_Gpio.c file and
// illustrates how to set the GPIO to it's default state.
// InitGpio();  // Skipped for this example
// Setup only the GP I/O only for SPI-A functionality
// This function is found in F2837xD_Spi.c
   InitSpiaGpio();

// Step 3. Clear all __interrupts and initialize PIE vector table:
// Disable CPU __interrupts
   DINT;

// Initialize PIE control registers to their default state.
// The default state is all PIE __interrupts disabled and flags
// are cleared.
// This function is found in the F2837xD_PieCtrl.c file.
   InitPieCtrl();

// Disable CPU __interrupts and clear all CPU __interrupt flags:
   IER = 0x0000;
   IFR = 0x0000;

// Initialize the PIE vector table with pointers to the shell Interrupt
// Service Routines (ISR).
// This will populate the entire table, even if the __interrupt
// is not used in this example.  This is useful for debug purposes.
// The shell ISR routines are found in F2837xD_DefaultIsr.c.
// This function is found in F2837xD_PieVect.c.
   InitPieVectTable();

// Step 4. Initialize the Device Peripherals:
   spi_fifo_init();   // Initialize the Spi FIFO
   spi_init();        // init SPI

// Step 5. User specific code:
// Interrupts are not used in this example.
   sdata = 0x1122FF55;
/*
   sendDataToDriver(0xEC00,0x000100C3);  //CHOPCONF: TOFF=3, HSTRT=4, HEND=1, TBL=2, CHM=0 (SpreadCycle)
   delay_loop();
   sendDataToDriver(0X9000,0x00060603); // IHOLD_IRUN: IHOLD=03, IRUN=06 , IHOLDDELAY=6
   delay_loop();
   sendDataToDriver(0x9100,0x0000000A); // TPOWERDOWN=10: Delay before power down in stand still
   delay_loop();
   sendDataToDriver(0x8000,0x00000004); // EN_PWM_MODE=1 enables StealthChop (with default PWMCONF)
   delay_loop();
   sendDataToDriver(0x9300,0x000001F4); // TPWM_THRS=500 yields a switching velocity about 35000 = ca. 30RPM
   delay_loop();
   sendDataToDriver(0xF000,0x000401C8);  // PWMCONF: AUTO=1, 2/1024 Fclk, Switch amplitude limit=200, Grad=1
   delay_loop();


     sendDataToDriver(0xA400,0x000003E8); // A1 = 1000 First acceleration
   //sendDataToDriver(0xA400,0x000000E8); // A1 = 1000 First acceleration
   delay_loop();
    sendDataToDriver(0xA500,0x0000C350); // V1 = 50000 Acceleration threshold velocity V1
 //  sendDataToDriver(0xA500,0x00000100);
   delay_loop();
    sendDataToDriver(0xA600,0X000001F4); // AMAX = 500 Acceleration above V1
  // sendDataToDriver(0xA600,0X00000125); // A = 500 Acceleration above V1
   delay_loop();
     sendDataToDriver(0XA700,0x00030D40); // VMAX = 200000
  // sendDataToDriver(0XA700,0x0000D167); // V = 500
   delay_loop();
     sendDataToDriver(0xA800,0x000002BC); // DMAX = 700 Deceleration above V1
 // sendDataToDriver(0xA800,0x000002BC);
   delay_loop();
     sendDataToDriver(0xAA00,0x00000578); // D1 = 1400 Deceleration below V1
  // sendDataToDriver(0xAA00,0x000001E8); // D1 = 1400 Deceleration below V1
   delay_loop();
    sendDataToDriver(0xAB00,0x0000000A); // VSTOP = 10 Stop velocity (Near to zero)
   delay_loop();
   sendDataToDriver(0xA000,0x000000000); // RAMPMODE = 0 (Target position move)
   delay_loop();
  // sendDataToDriver(0xAD00,0x7FFFFFFF);  MAX No of ROTATION
   sendDataToDriver(0xAD00,0xFFFF3800); // XTARGET
   delay_loop();

   sendDataToDriver(0x2100,0x00000000); // Query XACTUAL – The next read access delivers XACTUAL
   delay_loop();
 //  sendDataToDriver(0xA600,0X00000125); // A = 500 Acceleration above V1
  //   delay_loop();
   //  sendDataToDriver(0XA700,0x00000000); // VMAX = 500
  //   delay_loop();
  // sendDataToDriver(0xAD00,0x00000000); // XTARGET
  // delay_loop();
 //  sendDataToDriver(0x2100,0x00000000);
 //  delay_loop();
 //  sendDataToDriver(0xAD00,0xFFFF9C00);
  // delay_loop();
 //  sendDataToDriver(0x2100,0x00000000);
 //  delay_loop();
 //  sendDataToDriver(0xAD00,0x00000000);
   delay_loop();
*/
   sendDataToDriver(0xEC00,0x000100C3);
    delay_loop();
    sendDataToDriver(0X9000,0x00060603);
    delay_loop();
    sendDataToDriver(0x9100,0x0000000A);
    delay_loop();
    sendDataToDriver(0x8000,0x00000004);
    delay_loop();
    sendDataToDriver(0x9300,0x000001F4);
    delay_loop();
    sendDataToDriver(0xF000,0x000401C8);
    delay_loop();
    sendDataToDriver(0xA400,0x000003E8);
    delay_loop();
    sendDataToDriver(0xA500,0x0000C350);
    delay_loop();
    sendDataToDriver(0xA600,0X000001F4);
    delay_loop();
    sendDataToDriver(0XA700,0x00030D40);
    delay_loop();
    sendDataToDriver(0xA800,0x000002BC);
    delay_loop();
    sendDataToDriver(0xAA00,0x00000578);
    delay_loop();
    sendDataToDriver(0xAB00,0x0000000A);
    delay_loop();
    sendDataToDriver(0xA000,0x00000000);
    delay_loop();
    sendDataToDriver(0xAD00,0xFFFF3800);
    delay_loop();
    sendDataToDriver(0x2100,0x00000000);
    delay_loop();
    sendDataToDriver(0x2100,0x00000000);
    delay_loop();
    sendDataToDriver(0x2100,0x00000000);
    delay_loop();
    sendDataToDriver(0xAD00,0x00000000);
    delay_loop();
/*   for(;;)
   {
     // Transmit data
       spi_xmit(sdata1);
       spi_xmit(sdata2);
       spi_xmit(sdata3);
       spi_xmit(sdata4);
       //spi_xmit(0X2288);

     // Wait until data is received
    // while(SpiaRegs.SPIFFRX.bit.RXFFST !=1) { }
     rdata = SpiaRegs.SPIRXBUF;
     printf("Rdata = %X\n", rdata);
     // Check against sent data

     delay_loop();
    // if(rdata != sdata) error();
  //   sdata++;
   }
   */
}

// Step 7. Insert all local Interrupt Service Routines (ISRs) and functions here:

void delay_loop()
{
    long      i;
    for (i = 0; i < 1000000; i++) {}
}

void error(void)
{
    asm("     ESTOP0");                     // Test failed!! Stop!
    for (;;);
}

void spi_init()
{
   /* SpiaRegs.SPICCR.all =0x000F;                 // Reset on, rising edge, 16-bit char bits
    SpiaRegs.SPICTL.all =0x0006;                 // Enable master mode, normal phase,
                                                 // enable talk, and SPI int disabled.
    SpiaRegs.SPIBRR.all =0x0031;
    SpiaRegs.SPICCR.all =0x009F;                 // Relinquish SPI from Reset
    SpiaRegs.SPIPRI.bit.FREE = 1;                // Set so breakpoints don't disturb xmission
    */
    // Set reset low before configuration changes
       // Clock polarity (0 == rising, 1 == falling)
       // 16-bit character
       // Enable loop-back
       SpiaRegs.SPICCR.bit.SPISWRESET = 0;
       SpiaRegs.SPICCR.bit.CLKPOLARITY = 0;//navya //0
      // SpiaRegs.SPICCR.bit.SPICHAR = (16-1);
       SpiaRegs.SPICCR.bit.SPICHAR = 7; //8 bit
       SpiaRegs.SPICCR.bit.SPILBK = 0;

       // Enable master (0 == slave, 1 == master)
       // Enable transmission (Talk)
       // Clock phase (0 == normal, 1 == delayed)
       // SPI interrupts are disabled
       SpiaRegs.SPICTL.bit.MASTER_SLAVE = 1;
       SpiaRegs.SPICTL.bit.TALK = 1;
       SpiaRegs.SPICTL.bit.CLK_PHASE = 0;
       SpiaRegs.SPICTL.bit.SPIINTENA = 0;

       // Set the baud rate
       SpiaRegs.SPIBRR.bit.SPI_BIT_RATE = 0x31; //navya

       // Set FREE bit
       // Halting on a breakpoint will not halt the SPI
       SpiaRegs.SPIPRI.bit.FREE = 1;

       // Release the SPI from reset
       SpiaRegs.SPICCR.bit.SPISWRESET = 1;
}

void spi_xmit(Uint16 a)
{
    SpiaRegs.SPITXBUF=a;
}

void spi_fifo_init()
{
// Initialize SPI FIFO registers
    SpiaRegs.SPIFFTX.all=0xE040;
    SpiaRegs.SPIFFRX.all=0x2044;
    SpiaRegs.SPIFFCT.all=0x0;
}

void sendDataToDriver(Uint16 address, Uint32 sdata)
{
    Uint16 sdata1;
    Uint16 sdata2;
    Uint16 sdata3;
    Uint16 sdata4;
    Uint16 rdata=0xFFFF;  // received data
    sdata1 =(sdata>>16) & 0XFF00;
    sdata2 =(sdata>>8) & 0XFF00;
    sdata3 =(sdata) & 0XFF00;
    sdata4 = (sdata<<8) & 0XFF00;


    spi_xmit(address);
   //  Wait until data is received
  //  while(SpiaRegs.SPIFFRX.bit.RXFFST !=1) { }
 //   rdata = SpiaRegs.SPIRXBUF;
    spi_xmit(sdata1);
    // Wait until data is received
  //  while(SpiaRegs.SPIFFRX.bit.RXFFST !=1) { }
  //  rdata = SpiaRegs.SPIRXBUF;
    spi_xmit(sdata2);
   //  Wait until data is received
  //  while(SpiaRegs.SPIFFRX.bit.RXFFST !=1) { }
  //  rdata = SpiaRegs.SPIRXBUF;
    spi_xmit(sdata3);
   //  Wait until data is received
  //  while(SpiaRegs.SPIFFRX.bit.RXFFST !=1) { }
   // rdata = SpiaRegs.SPIRXBUF;
    spi_xmit(sdata4);
   //  Wait until data is received
  //  while(SpiaRegs.SPIFFRX.bit.RXFFST !=1) { }
  // rdata = SpiaRegs.SPIRXBUF;
// delay_loop();

}
//===========================================================================
// No more.
//===========================================================================

TMS320F28388D 控制器的代码

//###########################################################################
//
// FILE:   spi_ex1_loopback.c
//
// TITLE:  SPI Digital Loop Back Example.
//
//! \addtogroup bitfield_example_list
//! <h1>SPI Digital Loop Back </h1>
//!
//!  This program uses the internal loop back test mode of the peripheral.
//!  Other than boot mode pin configuration, no other hardware configuration
//!  is required. Interrupts are not used.
//!
//!  A stream of data is sent and then compared to the received stream.
//!  The sent data looks like this: \n
//!  0000 0001 0002 0003 0004 0005 0006 0007 .... FFFE FFFF \n
//!  This pattern is repeated forever.
//!
//!  \b Watch \b Variables \n
//!  - \b sdata - sent data
//!  - \b rdata - received data
//!
//
//###########################################################################
//
//
// $Copyright:
// Copyright (C) 2021 Texas Instruments Incorporated - http://www.ti.co/
//
// Redistribution and use in source and binary forms, with or without 
// modification, are permitted provided that the following conditions 
// are met:
// 
//   Redistributions of source code must retain the above copyright 
//   notice, this list of conditions and the following disclaimer.
// 
//   Redistributions in binary form must reproduce the above copyright
//   notice, this list of conditions and the following disclaimer in the 
//   documentation and/or other materials provided with the   
//   distribution.
// 
//   Neither the name of Texas Instruments Incorporated nor the names of
//   its contributors may be used to endorse or promote products derived
//   from this software without specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// $
//###########################################################################

//
// Included Files
//
#include "f28x_project.h"

//
// Function Prototypes
//
void transmitData(uint16_t a);
void initSPIFIFO(void);
void error(void);
void InitSpi(void);
void sendDataToDriver(Uint16 address, Uint32 sdata);
void delay_loop(void);
void spi_gpio(void);
void main(void)
{
    uint16_t sdata;  // sent data
    uint16_t rdata;  // received data

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

    //
    // Disable CPU interrupts
    //
    DINT;
    spi_gpio();
    //
    // Initialize the PIE control registers to their default state.
    // The default state is all PIE interrupts disabled and flags
    // are cleared.
    //
    InitPieCtrl();

    //
    // Disable CPU interrupts and clear all CPU interrupt flags
    //
    IER = 0x0000;
    IFR = 0x0000;

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

    //
    // Set up SPI, initializing it for FIFO mode
    //
    initSPIFIFO();

    //
    // Loop forever. Suspend or place breakpoints to observe the buffers.
    //
    sdata = 0x0000;
   ////////////////////////////////////////////////////////////

    sendDataToDriver(0xEC00,0x000100C3);
    delay_loop();
   sendDataToDriver(0X9000,0x00060603);
    delay_loop();
    sendDataToDriver(0x9100,0x0000000A);
    delay_loop();
    sendDataToDriver(0x8000,0x00000004);
    delay_loop();
    sendDataToDriver(0x9300,0x000001F4);
    delay_loop();
    sendDataToDriver(0xF000,0x000401C8);
    delay_loop();
    sendDataToDriver(0xA400,0x000003E8);
    delay_loop();
    sendDataToDriver(0xA500,0x0000C350);
    delay_loop();
    sendDataToDriver(0xA600,0X000001F4);
    delay_loop();
    sendDataToDriver(0XA700,0x00030D40);
    delay_loop();
    sendDataToDriver(0xA800,0x000002BC);
    delay_loop();
    sendDataToDriver(0xAA00,0x00000578);
    delay_loop();
    sendDataToDriver(0xAB00,0x0000000A);
    delay_loop();
    sendDataToDriver(0xA000,0x00000000);
    delay_loop();
    sendDataToDriver(0xAD00,0xFFFF3800);
    delay_loop();
    sendDataToDriver(0x2100,0x00000000);
    delay_loop();
    sendDataToDriver(0x2100,0x00000000);
    delay_loop();
    sendDataToDriver(0x2100,0x00000000);
    delay_loop();
    sendDataToDriver(0xAD00,0x00000000);
    delay_loop();
    //////////////////////////////////////
   /*
   for(;;)
    {
        //
        // Transmit data
        //
        transmitData(sdata);

        //
        // Wait until data is received
        //
        while(SpiaRegs.SPIFFRX.bit.RXFFST != 1)
        {

        }

        //
        // Check against sent data
        //
        rdata = SpiaRegs.SPIRXBUF;
        if(rdata != sdata)
        {
            error();
        }
        sdata++;
    }
*/


}

//
// error - Error function that halts the debugger
//
void error(void)
{
    asm("     ESTOP0");     // Test failed!! Stop!
    for(;;);
}

//
// transmitData - Transmit value via SPI
//
void transmitData(uint16_t a)
{
    SpiaRegs.SPITXBUF = a;
}

//
// initSPIFIFO - Initialize SPIA FIFO
//
void initSPIFIFO(void)
{
    //
    // Initialize SPI FIFO registers
    //
    SpiaRegs.SPIFFTX.all = 0xE040;
    SpiaRegs.SPIFFRX.all = 0x2044;
    SpiaRegs.SPIFFCT.all = 0x0;

    //
    // Initialize core SPI registers
    //
    InitSpi();
}

//
// InitSPI - This function initializes the SPI to a known state
//
void InitSpi(void)
{
    //
    // Initialize SPI-A
    //

    //
    // Set reset low before configuration changes
    // Clock polarity (0 == rising, 1 == falling)
    // 16-bit character
    // Enable loop-back
    //
    SpiaRegs.SPICCR.bit.SPISWRESET = 0;
    SpiaRegs.SPICCR.bit.CLKPOLARITY = 0;
    SpiaRegs.SPICCR.bit.SPICHAR = 7;
    SpiaRegs.SPICCR.bit.SPILBK = 0;

    //
    // Enable master (0 == slave, 1 == master)
    // Enable transmission (Talk)
    // Clock phase (0 == normal, 1 == delayed)
    // SPI interrupts are disabled
    //
    SpiaRegs.SPICTL.bit.MASTER_SLAVE = 1;
    SpiaRegs.SPICTL.bit.TALK = 1;
    SpiaRegs.SPICTL.bit.CLK_PHASE = 0;
    SpiaRegs.SPICTL.bit.SPIINTENA = 0;

    //
    // Set the baud rate using a 1 MHz SPICLK
    // BRR = (LSPCLK / SPICLK) - 1
    //
    SpiaRegs.SPIBRR.bit.SPI_BIT_RATE = 0x31;

    // Set FREE bit
    // Halting on a breakpoint will not halt the SPI
    //
    SpiaRegs.SPIPRI.bit.FREE = 1;

    //
    // Release the SPI from reset
    //
    SpiaRegs.SPICCR.bit.SPISWRESET = 1;
}


void sendDataToDriver(Uint16 address, Uint32 sdata)
{
    Uint16 sdata1;
    Uint16 sdata2;
    Uint16 sdata3;
    Uint16 sdata4;
    Uint16 rdata=0xFFFF;  // received data
    sdata1 =(sdata>>16) & 0XFF00;
    sdata2 =(sdata>>8) & 0XFF00;
    sdata3 =(sdata) & 0XFF00;
    sdata4 = (sdata<<8) & 0XFF00;


    transmitData(address);
   //  Wait until data is received
  //  while(SpiaRegs.SPIFFRX.bit.RXFFST !=1) { }
 //   rdata = SpiaRegs.SPIRXBUF;
    transmitData(sdata1);
    // Wait until data is received
  //  while(SpiaRegs.SPIFFRX.bit.RXFFST !=1) { }
  //  rdata = SpiaRegs.SPIRXBUF;
    transmitData(sdata2);
   //  Wait until data is received
  //  while(SpiaRegs.SPIFFRX.bit.RXFFST !=1) { }
  //  rdata = SpiaRegs.SPIRXBUF;
    transmitData(sdata3);
   //  Wait until data is received
  //  while(SpiaRegs.SPIFFRX.bit.RXFFST !=1) { }
   // rdata = SpiaRegs.SPIRXBUF;
    transmitData(sdata4);
   //  Wait until data is received
  //  while(SpiaRegs.SPIFFRX.bit.RXFFST !=1) { }
  // rdata = SpiaRegs.SPIRXBUF;
// delay_loop();

}
void delay_loop()
{
    long      i;
    for (i = 0; i < 1000000; i++) {}
}

void spi_gpio(void)
{
    EALLOW;

    /* Enable internal pull-up for the selected pins */
    // Pull-ups can be enabled or disabled by the user.
    // This will enable the pullups for the specified pins.
    // Comment out other unwanted lines.

        GpioCtrlRegs.GPAPUD.bit.GPIO16 = 0;   // Enable pull-up on GPIO16 (SPISIMOA)
    //  GpioCtrlRegs.GPAPUD.bit.GPIO5 = 0;    // Enable pull-up on GPIO5 (SPISIMOA)
        GpioCtrlRegs.GPAPUD.bit.GPIO17 = 0;   // Enable pull-up on GPIO17 (SPISOMIA)
    //  GpioCtrlRegs.GPAPUD.bit.GPIO3 = 0;    // Enable pull-up on GPIO3 (SPISOMIA)
        GpioCtrlRegs.GPAPUD.bit.GPIO18 = 0;   // Enable pull-up on GPIO18 (SPICLKA)
        GpioCtrlRegs.GPAPUD.bit.GPIO19 = 0;   // Enable pull-up on GPIO19 (SPISTEA)

    /* Set qualification for selected pins to asynch only */
    // This will select asynch (no qualification) for the selected pins.
    // Comment out other unwanted lines.

        GpioCtrlRegs.GPAQSEL2.bit.GPIO16 = 3; // Asynch input GPIO16 (SPISIMOA)
    //  GpioCtrlRegs.GPAQSEL1.bit.GPIO5 = 3;  // Asynch input GPIO5 (SPISIMOA)
        GpioCtrlRegs.GPAQSEL2.bit.GPIO17 = 3; // Asynch input GPIO17 (SPISOMIA)
    //  GpioCtrlRegs.GPAQSEL1.bit.GPIO3 = 3;  // Asynch input GPIO3 (SPISOMIA)
        GpioCtrlRegs.GPAQSEL2.bit.GPIO18 = 3; // Asynch input GPIO18 (SPICLKA)
        GpioCtrlRegs.GPAQSEL2.bit.GPIO19 = 3; // Asynch input GPIO19 (SPISTEA)

    /* Configure SPI-A pins using GPIO regs*/
    // This specifies which of the possible GPIO pins will be SPI functional pins.
    // Comment out other unwanted lines.

        GpioCtrlRegs.GPAMUX2.bit.GPIO16 = 1; // Configure GPIO16 as SPISIMOA
    //  GpioCtrlRegs.GPAMUX1.bit.GPIO5 = 2;  // Configure GPIO5 as SPISIMOA
        GpioCtrlRegs.GPAMUX2.bit.GPIO17 = 1; // Configure GPIO17 as SPISOMIA
    //  GpioCtrlRegs.GPAMUX1.bit.GPIO3 = 2;  // Configure GPIO3 as SPISOMIA
        GpioCtrlRegs.GPAMUX2.bit.GPIO18 = 1; // Configure GPIO18 as SPICLKA
        GpioCtrlRegs.GPAMUX2.bit.GPIO19 = 1; // Configure GPIO19 as SPISTEA

        EDIS;
}
//
// End of file
//

同时连接示波器图像：

任何意见都将非常有帮助。

请提前感谢

纳维亚·安娜·王子

3 年多前

0 admin 3 年多前

TI__Guru**** 2555630 points

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

纳维亚

F28377D 和 F28388之间的 SPI 模块大致相同。因此，两台设备的配置代码相同。从 SPI 的角度看，它应该同样起作用。

但是，F28377D 和 F28388是两种不同的器件，请检查 TMS320F2837x 和 TMS320F2838x 之间的迁移情况

您正尝试传输什么内容，以及您希望接收什么内容？我也不知道如何利用您的示波器图片。

此致，

马诺伊

0 admin 3 年多前

TI__Guru**** 2555630 points

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

你好，Manoj，

感谢您的回复。

从 SPI 的角度看， F28377D 和 F28388之间没有区别。

我使用了 C2000中提供的 SPI 环回示例代码来构建我的代码。我认为 F28388所需的任何额外配置都将在此处处理。

我还检查了您上面提到的文档，了解需要启用的任何额外设备配置。

我们正在尝试通过五次传输8字节来传输40字节(8字节地址+32字节数据)的数据。我们已将 SPI 字长配置为8，速度配置为1MHz。 但我们没有收到错误路线的预期结果。

我们观察到的另一件事是，以下路径 \ti\c2000\c2000\C2000Ware_4_00_00\device_support\f2838x\examples\CPU1\SPI 中存在的示例代码 SPI_ex1_loopback．c 没有 启用 SPI_GPIO 的任何功能。这是为什么？

谢谢

纳维亚·安娜·王子

0 admin 3 年多前

TI__Guru**** 2555630 points

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

SPI_ex1_loopback.c 示例不需要配置 SPI GPIO，因为 SPIMOSI 和 SPIMISO 信号内部连接。此示例通常用于在自检模式下验证 SPI。它不用于典型的 usecase。

我建议您使用 C:\ti\C2000 \C2000Ware_4_00_00_00\driverlib\f2838x\中提供的 SPI 驱动程序库功能

并检查诸如 SPI_DOWNBytes(Base，txBuffer，numOfWords，txDelay)等函数。这将使您不必担心 SPI 配置等，因为它将为您提供服务。

关于您在错误线路上获得意外价值的问题，我无能为力，因为我无法访问您的硬件。您需要执行调试以了解发生了什么错误。

此致，

马诺伊

C2000™︎ 微控制器（参考译文帖）

C2000™︎ 微控制器（参考译文帖）(Read Only)

[参考译文] TMS320F28388D：为 TMS320F28388D 控制卡配置 SPIA 寄存器时出现问题