[参考译文] TMDSCNCD28388D：C2000以太网

您好！

是的、您可以将 packetData 替换为 send_buff。 确保该变量位于共享 RAM 中。  #pragma DATA_SECTION (SEND_缓冲 区、"MSGRAM_CPU_TO_CM")。

按地址表示指向数组的指针。  

这意味着它是 从地址起始位置(send_buff)发送的数据的长度

-yashwant

大家好、Yashwant Temburu

我在 enet_lwip 项目下添加了 IPC 代码。 请告诉我、CPU1通过 IPC 发送的数据位于 enet_lwip 项目下 void IPC_ISR0 ()的 IPC_readCommand 函数中。 以太网接收和发送的数据格式固定了多少字节？ 格式是什么？ 如何通过我一侧的以太网芯片发送接收到的数据？
在计算机上、有相应的主机软件、它能否接收和显示数据？ 我之前说过的是使用网页的形式来接收和显示计算机上的数据。 但是、在阅读之前给出的链接后、此网页的形式仍然有点混乱、我不太可能更改它。

另一点是、我对调整28388D 以太网和计算机之间的数据通信有点困惑。 请帮助我澄清我的想法。 (我的数据是从 CPU1的 CAN 端口接收150个字符的数据、然后我希望通过以太网端口将其发送到计算机、并在计算机上接收数据、并且可以实时显示和保存)

整个过程在硬件 TMDSCNCD28388D (28388D 的评估板)中完成。

谢谢

Vince

大家好、Yashwant Temburu

数据长度为150个字符。 如何将其拆分并通过 IPC_sendCommand 函数将其发送出去？
对于 CAN 发送功能、一次最多可发送8个字节。 我的过程是将150个字节拆分为8个字节的数据并将其发送出去。 可以接收数据、数据也以8字节的数据包形式接收、然后传输到新的数组。

在 enet_lwip 项目下、哪个函数可以从以太网芯片发送数据？

谢谢

Vince

大家好、Yashwant Temburu

Ethernet_sendPacket 的功能是向计算机发送数据？

与您的沟通时间很长、因此请同时提出几个问题。

谢谢

Vince

大家好、Yashwant Temburu

Ethernet_sendPacket (EMAC_Handle、&pktDesc)；pktDesc 指向的数组中的数据是否发送到何处？ 发送的格式是什么？
该函数位于 enet_lwip 项目下的 enet_lwip.c 文件中。

谢谢

Vince

此函数将数据发送到 Mac 层。 您可以通过"Wireshark "应用程序将主机 PC 中的各个数据包可视化。  

由于这是一个低级驱动程序函数、因此不会附加任何更高层的堆栈头。

Pktdesc 是指向数据包描述符的指针、该描述符具有多个字段、包括数据包大小、数据包数据缓冲器指针等)。 根据这些字段、数据包数据被传输到 Mac 层。

您可以浏览数据包描述符的结构定义、并根据数据更新变量的字段。

您可以在传输时定义数据包长度。 如果配置为未使用大型数据包、则最多可传输1500字节。

您可以通过 IPC 发送整个150字节。  

-yashwant

大家好、Yashwant Temburu

Ethernet_sendPacket (EMAC_Handle 和 pktDesc)

此函数将数据发送到 Mac 层。 能否使用 Wireshark 软件查看数据？

是否仍需要在 enet_lwip 项目下修改以下回送模式以禁用它？

pInitCfg->loopbackMode = Ethernet_MAC_configuration_LM_loopback_disabled;

同事还应注释出用于发送和接收数据验证的模块代码、对吧？

只有在完成上述两项操作并在 Wireshark 软件中过滤您自己的 IP 地址后、您才能观察 EtherNet_sendPacket (EMAC_Handle 和 pktDesc)函数发送的数据(IP 地址已更改为219.246.2.1)。

谢谢

Vince

大家好、Yashwant Temburu

上图是在使用 Wireshark 软件后捕获开发板的 IP：219.246.2.1数据包的结果。

下图是 Wireshark 软件的详细信息。

这是一个问题：

我在 enet_lwip 例程中将 IP 地址修改为219.246.2.1、同时将 cm_common_config_C28x.c 中的 packetData[packet_length]数组分配为132位。

根据常识、Wireshark 软件中捕获的 IP 地址为219.246.2.1的数据包应是下面分配的数据。 但是、在 Wireshark 接口中未找到相关数据。

出了什么问题？

uint8_t packetData[packet_length]=｛"12312111311131113132716241271894886369111324375127189483699101129011437011010070110871101005210100000110133110199571112345671"｝；

谢谢

Vince

大家好、Yashwant Temburu

尝试禁用环回模式后、Wireshark 软件中的现象与以前没有什么不同。
它必须位于 enet_lwip 例程中、并且不会注释回送程序、或者存在其他原因。
它真的没有找到原因。

谢谢

Vince

大家好、Yashwant Temburu

如果整个 CPU1数据发送到 CM4内核、则 CM4控制以太网芯片以将数据发送出去、最后 Wireshark 软件接收数据、然后在 Wireshark 软件的哪个区域显示数据？

谢谢

Vince

大家好、Yashwant Temburu

uint8_t packetData[packet_length]=｛"12312111311131113132716241271894886369111324375127189483699101129011437011010070110871101005210100000110133110199571112345671"｝；
该数组的数据组成应该错误。 第一个位数应为接收数据终端(笔记本电脑)的 IP 地址、后跟要发送的数据。 对吧？

还有另一个问题。 自动获取我的笔记本电脑的 IP 地址。 我使用 cmd 的 ipconfig 命令获取 IPv4、它是我的笔记本电脑的 IP 地址(219.246.2.128)(如下所示)。

然后，将 IP 地址放入上述数组中，并使用数据构成一个完整数组。 如下所示：
uint8_t packetData[packet_length]=｛"219.246.2.128.271624127189488636911132437512718948369910112901143701107011010087110100521010000011010133110199571112345671"｝；
这是我的想法、请帮助工程师查看是否存在任何问题。
这与开发板通过以太网通信向笔记本电脑发送数据有关。 考虑数据的格式和组成、请帮助查看是否存在问题。

谢谢

Vince

你是对的。 您必须将必要的标头添加到数据帧(IP 标头、TCP 标头等)。  

我们对开放源代码 lwIP 堆栈的理解也很有限、无法帮助您对网络堆栈进行单独查询。 您可以在一些开放源码 lwIP 论坛上提问。

在网络中搜索使用 lwIP 的器件之间的套接字通信。  它应该会为您提供一些现有示例、您的 PC 可以在其中绑定到器件并与其进行通信。

-yashwant

大家好、Yashwant Temburu

存在问题、enet_lwip 是例程、我将其复制到工作区并进行修改。 发现 c 驱动器上的文件也发生了变化。 当系统提示需要更新 C2000ware 时、更新结束、修改后保存的 enet_lwip 例程更新为最原始的状态。

是否有任何链接文件可以删除以解决此问题？ 或者、是否需要在过去创建一个新项目并放置 enet_lwip 例程？

谢谢

Vince

当前所有 lwip 文件都链接到工程。  

您可以在 CCS GUI 中删除这些链接的文件。 它应删除链接并创建链接文件的副本。

-yashwant

谢谢

大家好、Yashwant Temburu

我在例程 EtherNet_C28x_config 中将 packet_length 的长度修改为1、然后观察到 pktDesc 中的 bufferlength 也在 enet_lwip 中更改为1。 但是，pktDesc 中的数据库总是为4。 无论我如何修改 packetData[packet_length]的赋值、pktDesc 中的数据库始终为4。
我的 IPC 代码添加不正确、不起作用了吗？
但是、如果 IPC 不起作用、为什么 packet_length 的长度会随 CPU1的分配而变化？

我想将 packetData[packet_length]中的值发送到 CM 内核。 为什么 pktDesc 中的数据总线永远不会改变？ 出了什么问题？

谢谢

Vince

大家好、Yashwant Temburu

我现在使用的以太网的数据帧格式是什么？

谢谢

Vince

大家好、Yashwant Temburu

当我们发送以太网数据帧时、我们是否需要自行打包数据帧？ 或者、例程中是否有打包的数据包、只需更改数据包的数据部分？

谢谢

Vince

大家好、Yashwant Temburu

下图中显示的网页代表什么？

在上一个程序中、方框中有数字。 这些数字代表什么？

谢谢

Vince

大家好、Yashwant Temburu

https://e2e.ti.com/support/microcontrollers/c2000-microcontrollers-group/c2000/f/c2000-microcontrollers-forum/502741/concerto-enet_lwip-hard-faults

我看到一些帖子说在例行程序中存在 lwip 问题？ 这些问题是否已得到解决？

谢谢

Vince

大家好、Yashwant Temburu

我想问的是、我们的 lwip 协议、下图中使用了哪个数据包？

谢谢

Vince

大家好、Yashwant Temburu

在这里、是否是从开发板捕获的数据？ 我在 enet_lwip 例程中找不到为数组分配值的位置。 没有什么地方能找到 abcdefghijk…… 分配。
这些数据来自哪里？

谢谢

Vince

F28388D 的以太网模块支持 IEEE 802.3格式。  

是的、这来自电路板。 它是对 ICMP 数据包的应答，因此您可以将数据分配给该数据包。 它只是主机 PC 发送的 ICMP 请求中接收到的数据的重新传输。

这些数字是反映在器件代码中的全局值。

我尝试在 https://e2e.ti.com/support/microcontrollers/c2000-microcontrollers-group/c2000/f/c2000-microcontrollers-forum/998994/tms320f28388d-c2000-microcontrollers-forum 的 fs.c 中解释这一数据。 请参阅每份回复。

是的、这些问题已经解决。 对于下一个 C2000Ware 版本、将整合这些内容。

此致、

Yashwant

大家好、Yashwant Temburu

上图应表明 CPU1已通过 IPC 通道将数据发送到 CM4内核？

可以解释的是、数组 packetData[packet_length]中的数据；CPU1内核中的数据已成功写入 CPU1TOCMRAM 中、对吧？

然后从第一张图片中、您可以在 CM4内核程序中找到 pktDESC.dataBuffer =(uint8_t *) addr

说明 CPU1的数组 packetData[packet_length]中的数据被传输到 CM4内核的 pktDESC.dataBuffer。

通过这种方式、这意味着我的示例中从 CPU1内核到 CM4内核的数据传输 IPC 是否成功？

那么、如何通过以太网网络端口将 CM4内核的 pktDESC.dataBuffer 数据发送到计算机以进行显示呢？

我的分析是 Ethernet_sendPacket (EMAC_Handle、&pktDesc)；语句在上图的第二幅图中、其功能是通过 ethernet_sendPacket 函数将 CM4内核中 IPC 通道接收到的数据发送到以太网芯片上的 TX 端口？

如果是这种情况、如何捕获计算机上 EtherNet_sendPacket 函数发送的数据？

谢谢

Vince

大家好、Yashwant Temburu

在当前情况下、是否可以使用此软件接收开发板发送的数据？ 在此软件中选择哪种协议？
从何处可以获取开发板的 IP 地址和端口号？

谢谢

Vince

大家好、Yashwant Temburu

如何发送从 CPU1接收到的阵列 pktDESC.dataBuffer、Wireshark 软件也可以抓取阵列 pktDESC.dataBuffer 的内容。

CM4中的 IPC 中断功能如下：

空 IPC_ISR0()
｛
uint32_t 命令、addr、data；
//
//读取命令
//
IPC_readCommand (IPC_CM_L_CPU1_R、IPC_FLAG0、IPC_ADDR_CORRECT_ENABLE、
命令、addr、&data)；

if (command =IPC_CMD_READ_MEM)
｛
状态= true；
//
//读取缓冲区地址和长度
//从 IPC message从IPC信息中读取缓存地址和长度
//
pktDESC.dataBuffer =(uint8_t *) addr；
pktDESC.bufferLength =数据；
pktDESC.pktLength =数据；
pktDESC.validLength =数据；
//
//从 C28x 端接收消息时发送数据包
//
Ethernet_sendPacket (EMAC_Handle、&pktDesc)；
｝
｝

在我看来、语句 ethernet_sendPacket (emac_handle、&pktDesc)；发出数组 pktDesc.dataBuffer 的内容。 这个想法是不是错误的？
如果这个想法是可以的、那么我使用 Wireshark 软件是否有问题？ 如果出现这种问题、应如何执行正确的操作以成功接收 CPU1在 Wireshark 中发送的数组 pktDesc.dataBuffer 的数据？

谢谢

Vince

大家好、Yashwant Temburu

Ethernet_sendPacket (EMAC_Handle、&pktDesc)；语句将数据发送到 MAC 层。 我能否通过笔记本电脑上的 Wireshark 软件查看数据？

谢谢

Vince

大家好、Yashwant Temburu

我想知道是由于程序还是环回模式、数据不是从 CM4发送、而是从 CM4返回到 CPU1内核。
如果这是原因、我应该在哪里修改例程？

下面是使用的两个例程。

e2e.ti.com/.../ethernet_5F00_c28x_5F00_config.rare2e.ti.com/.../enet_5F00_CM_5F00_lwip.rar

谢谢

Vince

大家好、Yashwant Temburu

从笔记本电脑 ping 开发板时、通常会发生请求超时。 原因是什么？

谢谢

Vince

大家好、Yashwant Temburu

但是、当我退出程序时、它会运行。 然后关闭开发板电源、再次打开电源、然后按顺序运行 CPU1内核的程序、然后运行 CM4内核的程序。 此时、我使用 cmd 来 ping、发现请求超时情况会小得多、其中大多数是正常接收和发送数据。

我可以添加您的个人联系信息吗？ 有关28388D 的信息非常少。 我希望在您的帮助下尽快传输以太网。

谢谢

Vince

我使用 C2000Ware_3_04_00_00

OK，正在修订中

您好，Yashwant Temburu

我现在在项目下、替换了您为我的两个文件 enet_lwip.c 和 f2838xif.c 提供的代码
但您说过要更新 f2838x_cm driverlib 中的附件。
我没有找到此附件。

谢谢

Vince

您好，Yashwant Temburu

替换 enet_lwip.c 和 f2838xif.c 两个文件后、我替换了下图并对其进行了编译。 结果如下：

我也在寻找原因。

谢谢

Vince

您好，Yashwant Temburu

编译后、ethernet.h 文件整体呈灰色、感觉有点未使用。
我还需要问的一点是、如何在计算机上使用 Wireshark 来捕获开发板发送的数据？ 您的此示例仅具有用于驱动以太网程序的 CM4内核。 稍后需要 CPU1上的数据、需要将 IPC 代码添加到例程中、对吧？

我以前没有调整过以太网，我问的问题有点太有趣了，抱歉

谢谢

Vince

您好，Yashwant Temburu

如果我的开发板和笔记本电脑都连接到交换机、如何使笔记本电脑与开发板通信？

我的过程是修改 enet_lwip.c 中的 IP 地址

因为我的笔记本电脑被设置为自动识别 IP、所以我没有在笔记本电脑上使用 cmd 命令 ipconfig、并且找到了笔记本电脑自动获得的 IP 地址的网络段。 然后将 enet_lwip.c 中的 unsigned long ipaddr = 0xC0A80004；(192.168.0.4)更改为 unsigned long ipaddr = 0xDBF60201；(219.246.2.1)未进行其他更改。

之后、我使用 cmd 命令 ping 开发板程序中设置的 IP 地址219.246.2.1。 结果如下：

摘要：以上是我的理解。 开发板和笔记本电脑同时连接到交换机并希望进行通信。 如上图所示、有必要将开发板和笔记本电脑设置在同一网段上。 只需要修改 IP、不需要修改另一个、就是这样吗？

来询问

谢谢

Vince

您好，Yashwant Temburu

处理这个地方的考虑因素是什么？

谢谢

Vince

您好，Yashwant Temburu

在我的一侧、我希望通过网络调试助手接收开发板发送的数据。 但是、连接时始终报告错误。

此过程是否有问题？

谢谢

Vince

您好，Yashwant Temburu

下图是我通过使用 Wireshark 通过以下连接方法获取开发板的 MAC 地址而获得的数据包

连接方法：

开发板使用网线连接到交换机 A

笔记本电脑通过网线连接到交换机 A

连接后、笔记本电脑将更改 IPv4以自动获取 IP 地址。

然后、运行程序。

结果如下：

谢谢

Vince

尊敬的 Vince：

首先确认您是否能够使用提供的更新文件成功构建项目？ 如果成功构建、您是否能够通过直接连接到笔记本电脑与开发板进行通信、而不是将板连接到交换机。  

当前示例使用静态 IP 地址 、该地址使用变量 ipaddr 进行设置。  

为了使您的设置与交换机配合使用、您必须在示例中启用 DHCP、以便交换机可以自动为开发板分配 IP 地址。 搜索笔记本电脑如何通过交换机通过 DHCP 获取 ipaddress、以了解有关协议的更多信息。

MAC 地址(Mac_CUSTOM)对于每个设备都是唯一的、但主机可以通过 ARP 请求通信。

很抱歉、我们无法支持您在当前示例上所需的增强功能、但如果现有示例存在任何问题、我们可以为您提供帮助。

此致、

Yashwant

您好，Yashwant Temburu

大家好、我已经成功下载了它。 但是，不知道如何使用数据进行通信？ 同时、主机应如何使用软件来获取数据？
因为我的目的是将 CPU1的数据发送到 CM4内核、然后 CM4内核驱动以太网将数据发送到笔记本电脑。
我在您的回复中看到、我们现有的例程和技术不支持开发板连接到交换机以与笔记本电脑通信？
我只能通过网线直接连接开发板和笔记本电脑、然后再执行数据通信吗？

目前、我的进度如下图所示。

谢谢

Vince

我不知道该软件的用途是什么、但如果要将数据包数据传输到特定的 IP 地址、则可以直接在 应用器件代码中使用 EtherNet_rxBuffer、该代码包含主机发送的最新数据包数据。 然后、可以使用 IPC 将该数据传输到 C28x。

是的，它们不支持使用 DHCP 连接路由器。

您好，Yashwant Temburu

大家好、可能是我没有清楚地表达出来。 我的数据位于 CPU1中、然后需要通过 IPC 将其发送到 CM4内核、然后 CM4驱动以太网将该数据发送到笔记本电脑。 整个过程是单向的。
我有两个问题。 1.如何将您自己的数据放入整个过程，以确保最终数据被发送出去。
2.如何查看笔记本电脑上数据的实时变化。

谢谢

Vince

您好，Yashwant Temburu

我将 IPC 添加到 enet_lwip 例程、并将 IPC 程序添加到 EtherNet_C28x_config 中。 运行这两个例程。 存在问题：CPU1运行 EtherNet_C28x_CONFIG 例程、这是正常的。 但是、当 enet_lwip 例程下载到电路板并单击 Run 时、enet_lwip 例程中的程序将运行到_asm (" bkpt #0")；
原因是什么？

//#############################################################################
//
// FILE:   cm_common_config_c28x.c
//
// TITLE:  C28x Common Configurations to be used for the CM Side.
//
//! \addtogroup driver_example_list
//! <h1>C28x Common Configurations</h1>
//!
//! This example configures the GPIOs and Allocates the shared peripherals
//! according to the defines selected by the users.

#include "driverlib.h"
#include "device.h"
#include "CANA.h"

#define RX_MSG_OBJ_ID     1
#define MSG_DATA_LENGTH   8
#define MSGCOUNT          16
char send_flag=0;
#define can_receive_length  3    //*************************
char send_buf[can_receive_length]; //*************************
uint16_t  t = 0;
//************IPC*************
int i;
#define IPC_CMD_READ_MEM   0x1001
#define IPC_CMD_RESP       0x2001

#define TEST_PASS          0x5555
#define TEST_FAIL          0xAAAA

#define PACKET_LENGTH 132
#pragma DATA_SECTION(packetData, "MSGRAM_CPU_TO_CM")
uint8_t  packetData[PACKET_LENGTH];
//#pragma DATA_SECTION(send_buf, "MSGRAM_CPU_TO_CM")
uint32_t pass;
//************IPC*************

void main(void)
{
    Device_init();
    Device_initGPIO();
    //*********************CANA**************************************
    GPIO_setPinConfig(DEVICE_GPIO_CFG_CANRXA);
    GPIO_setPinConfig(DEVICE_GPIO_CFG_CANTXA);
    CAN_initModule(CANA_BASE);
    CAN_setBitRate(CANA_BASE, DEVICE_SYSCLK_FREQ, 500000, 20);
    CAN_enableInterrupt(CANA_BASE, CAN_INT_IE0 | CAN_INT_ERROR | CAN_INT_STATUS);
    //*********************CANA**************************************
//  GPIO_setPadConfig(DEVICE_GPIO_PIN_CANA, GPIO_PIN_TYPE_STD);
//  GPIO_setDirectionMode(DEVICE_GPIO_PIN_CANA, GPIO_DIR_MODE_OUT);
//  GPIO_setPadConfig(DEVICE_GPIO_PIN_232, GPIO_PIN_TYPE_STD);
//  GPIO_setDirectionMode(DEVICE_GPIO_PIN_232, GPIO_DIR_MODE_OUT);

    //********************SCIA   TX    232***************************
    GPIO_setMasterCore(8, GPIO_CORE_CPU1);
    GPIO_setPinConfig(GPIO_8_SCIA_TX);
    GPIO_setDirectionMode(8, GPIO_DIR_MODE_OUT);
    GPIO_setPadConfig(8, GPIO_PIN_TYPE_STD);
    GPIO_setQualificationMode(8, GPIO_QUAL_ASYNC);
    //
    // Boot CM core
    //
#ifdef _FLASH
    Device_bootCM(BOOTMODE_BOOT_TO_FLASH_SECTOR0);
#else
    Device_bootCM(BOOTMODE_BOOT_TO_S0RAM);
#endif

#ifdef ETHERNET
    //
    // Set up EnetCLK to use SYSPLL as the clock source and set the
    // clock divider to 2.
    //
    // This way we ensure that the PTP clock is 100 MHz. Note that this value
    // is not automatically/dynamically known to the CM core and hence it needs
    // to be made available to the CM side code beforehand.
    SysCtl_setEnetClk(SYSCTL_ENETCLKOUT_DIV_2, SYSCTL_SOURCE_SYSPLL);
    //
    // Configure the GPIOs for ETHERNET.
    //
    // MDIO Signals
    //
    GPIO_setPinConfig(GPIO_105_ENET_MDIO_CLK);
    GPIO_setPinConfig(GPIO_106_ENET_MDIO_DATA);
    //
    // Use this only for RMII Mode
    //GPIO_setPinConfig(GPIO_73_ENET_RMII_CLK);
    //

    //
    //MII Signals
    //
    GPIO_setPinConfig(GPIO_109_ENET_MII_CRS);
    GPIO_setPinConfig(GPIO_110_ENET_MII_COL);
    GPIO_setPinConfig(GPIO_75_ENET_MII_TX_DATA0);
    GPIO_setPinConfig(GPIO_122_ENET_MII_TX_DATA1);
    GPIO_setPinConfig(GPIO_123_ENET_MII_TX_DATA2);
    GPIO_setPinConfig(GPIO_124_ENET_MII_TX_DATA3);
    //
    //Use this only if the TX Error pin has to be connected
    //GPIO_setPinConfig(GPIO_46_ENET_MII_TX_ERR);
    //
    GPIO_setPinConfig(GPIO_118_ENET_MII_TX_EN);
    GPIO_setPinConfig(GPIO_114_ENET_MII_RX_DATA0);
    GPIO_setPinConfig(GPIO_115_ENET_MII_RX_DATA1);
    GPIO_setPinConfig(GPIO_116_ENET_MII_RX_DATA2);
    GPIO_setPinConfig(GPIO_117_ENET_MII_RX_DATA3);
    GPIO_setPinConfig(GPIO_113_ENET_MII_RX_ERR);
    GPIO_setPinConfig(GPIO_112_ENET_MII_RX_DV);
    GPIO_setPinConfig(GPIO_44_ENET_MII_TX_CLK);
    GPIO_setPinConfig(GPIO_111_ENET_MII_RX_CLK);
    //
    //Power down pin to bring the external PHY out of Power down
    //
    GPIO_setDirectionMode(108, GPIO_DIR_MODE_OUT);
    GPIO_setPadConfig(108, GPIO_PIN_TYPE_PULLUP);
    GPIO_writePin(108,1);
    //
    //PHY Reset Pin to be driven High to bring external PHY out of Reset
    //
    GPIO_setDirectionMode(119, GPIO_DIR_MODE_OUT);
    GPIO_setPadConfig(119, GPIO_PIN_TYPE_PULLUP);
    GPIO_writePin(119,1);
#endif

    Interrupt_initModule();
    Interrupt_initVectorTable();
    EINT;
    ERTM;
    //*********************CANA**************************************
    Interrupt_register(INT_CANA0,&canaISR);
    Interrupt_enable(INT_CANA0);
    CAN_enableGlobalInterrupt(CANA_BASE, CAN_GLOBAL_INT_CANINT0);
    CAN_setupMessageObject(CANA_BASE, RX_MSG_OBJ_ID, 0x000000,CAN_MSG_FRAME_STD, CAN_MSG_OBJ_TYPE_RX, 0,CAN_MSG_OBJ_USE_ID_FILTER|CAN_MSG_OBJ_RX_INT_ENABLE, MSG_DATA_LENGTH);
    CAN_startModule(CANA_BASE);
    //*********************CANA**************************************


//*************************************************IPC*********************************************************************************
    //
        //Form the unicast Ethernet Packet in Memory
        //在内存中形成单播以太网数据包
        for(i=0;i<PACKET_LENGTH/4;i++)
        {
            //
            //First 6 bytes of the packet are the MAC Destination Address
            //Bytes, the Destination and CRC shall be inserted by the hardware
            //数据包的前6个字节是MAC目标地址字节，目标和CRC必须由硬件插入
            if(i == 0)
                *((uint32_t *)packetData + i) = 0x01020304;
//                *((uint32_t *)send_buf + i) = 0x01020304;          //************将 packetData替换成send_buf*********************
            else if(i == 1)
                *((uint32_t *)packetData + i)  = 0xFFFF0506;
//                *((uint32_t *)send_buf + i)  = 0xFFFF0506;
            else
                HWREG((uint32_t *)packetData +i) = i;
//                HWREG((uint32_t *)send_buf +i) = i;
        }

        //
        // Clear any IPC flags if set already
        //
        IPC_clearFlagLtoR(IPC_CPU1_L_CM_R, IPC_FLAG_ALL);

        //
        // Synchronize both the cores.同步CPU1和CM内核。
        //
        IPC_sync(IPC_CPU1_L_CM_R, IPC_FLAG31);
        //
        // Send a message without message queue
        // Since C28x and CM does not share the same address space for shared RAM,
        // ADDRESS_CORRECTION is enabled
        // Length of the data to be read is passed as data.
        //
//        IPC_sendCommand(IPC_CPU1_L_CM_R, IPC_FLAG0, IPC_ADDR_CORRECTION_ENABLE,
//                        IPC_CMD_READ_MEM, (uint32_t)packetData, PACKET_LENGTH);

        IPC_sendCommand(IPC_CPU1_L_CM_R, IPC_FLAG0, IPC_ADDR_CORRECTION_ENABLE,IPC_CMD_READ_MEM, (uint32_t)packetData, PACKET_LENGTH);

        //
        // Wait for acknowledgment等待CM确认
        //
        IPC_waitForAck(IPC_CPU1_L_CM_R, IPC_FLAG0);

        //
        // Read response阅读回应
        //
        if(IPC_getResponse(IPC_CPU1_L_CM_R) == TEST_PASS)
        {
            pass = 1;
        }
        else
        {
            pass = 0;
        }
//************************************IPC************************************************************


    while(1)
    {
        //*********************232数据发送************************
        if(send_flag)
        {
            send_flag = 0;
            //GPIO_writePin(DEVICE_GPIO_PIN_232, 0);
            for(t=0;t<150;t++)
             {
                if(send_buf[t] == 0)
                 {
                    continue;
                 }
                SCI_writeCharBlockingNonFIFO(SCIA_BASE, send_buf[t]);
                if(send_buf[t] == '\n')
                 {
                    send_buf[t] = 0;
                    break;
                 }
                send_buf[t] = 0;
             }
          //  GPIO_writePin(DEVICE_GPIO_PIN_232, 1);
        }
        //*********************232数据发送************************
    }

#ifdef MCAN
    //
    // Setting the MCAN Clock.
    //
    SysCtl_setMCANClk(SYSCTL_MCANCLK_DIV_4);

    //
    // Configuring the GPIOs for MCAN.
    //
    GPIO_setPinConfig(DEVICE_GPIO_CFG_MCANRXA);
    GPIO_setPinConfig(DEVICE_GPIO_CFG_MCANTXA);
#endif

#ifdef CANA
    //
    // Configuring the GPIOs for CAN A.
    //
    GPIO_setPinConfig(DEVICE_GPIO_CFG_CANRXA);
    GPIO_setPinConfig(DEVICE_GPIO_CFG_CANTXA);

    //
    // Allocate Shared Peripheral CAN A to the CM Side.
    //
    SysCtl_allocateSharedPeripheral(SYSCTL_PALLOCATE_CAN_A,0x1U);
#endif

#ifdef CANB
    //
    // Configuring the GPIOs for CAN B.
    //
    GPIO_setPinConfig(DEVICE_GPIO_CFG_CANRXB);
    GPIO_setPinConfig(DEVICE_GPIO_CFG_CANTXB);

    //
    // Allocate Shared Peripheral CAN B to the CM Side.
    //
    SysCtl_allocateSharedPeripheral(SYSCTL_PALLOCATE_CAN_B,0x1U);
#endif

#ifdef UART
    //
    // Configure GPIO85 as the UART Rx pin.
    //
    GPIO_setPinConfig(GPIO_85_UARTA_RX);
    GPIO_setDirectionMode(85, GPIO_DIR_MODE_IN);
    GPIO_setPadConfig(85, GPIO_PIN_TYPE_STD);
    GPIO_setQualificationMode(85, GPIO_QUAL_ASYNC);

    //
    // Configure GPIO84 as the UART Tx pin.
    //
    GPIO_setPinConfig(GPIO_84_UARTA_TX);
    GPIO_setDirectionMode(84, GPIO_DIR_MODE_OUT);
    GPIO_setPadConfig(84, GPIO_PIN_TYPE_STD);
    GPIO_setQualificationMode(84, GPIO_QUAL_ASYNC);
#endif

#ifdef USB
#ifdef USE_20MHZ_XTAL
    //
    // Set up the auxiliary PLL so a 60 MHz output clock is provided to the USB module.
    // This fixed frequency is required for all USB operations.
    //
    SysCtl_setAuxClock(SYSCTL_AUXPLL_OSCSRC_XTAL |
                       SYSCTL_AUXPLL_IMULT(48) |
                       SYSCTL_REFDIV(2U) | SYSCTL_ODIV(4U) |
                       SYSCTL_AUXPLL_DIV_2 |
                       SYSCTL_AUXPLL_ENABLE |
                       SYSCTL_DCC_BASE_0);
#else
    //
    // Set up the auxiliary PLL so a 60 MHz output clock is provided to the USB module.
    // This fixed frequency is required for all USB operations.
    //
    SysCtl_setAuxClock(SYSCTL_AUXPLL_OSCSRC_XTAL |
                       SYSCTL_AUXPLL_IMULT(48) |
                       SYSCTL_REFDIV(2U) | SYSCTL_ODIV(5U) |
                       SYSCTL_AUXPLL_DIV_2 |
                       SYSCTL_AUXPLL_ENABLE |
                       SYSCTL_DCC_BASE_0);
#endif

    //
    // Allocate Shared Peripheral USB to the CM Side.
    //
    SysCtl_allocateSharedPeripheral(SYSCTL_PALLOCATE_USBA, 1);

    GPIO_setPinConfig(GPIO_0_GPIO0);
    GPIO_setPadConfig(0, GPIO_PIN_TYPE_STD);
    GPIO_setDirectionMode(0, GPIO_DIR_MODE_OUT);
    GPIO_setMasterCore(0, GPIO_CORE_CM);

    //
    // Set the master core of GPIOs to CM.
    //
    GPIO_setMasterCore(42, GPIO_CORE_CM);
    GPIO_setMasterCore(43, GPIO_CORE_CM);
    GPIO_setMasterCore(46, GPIO_CORE_CM);
    GPIO_setMasterCore(47, GPIO_CORE_CM);
    GPIO_setMasterCore(120, GPIO_CORE_CM);
    GPIO_setMasterCore(121, GPIO_CORE_CM);

    //
    // Set the USB DM and DP GPIOs.
    //
    GPIO_setAnalogMode(42, GPIO_ANALOG_ENABLED);
    GPIO_setAnalogMode(43, GPIO_ANALOG_ENABLED);

    //
    // Set the direction for VBUS and ID.
    //
    GPIO_setDirectionMode(46, GPIO_DIR_MODE_IN);
    GPIO_setDirectionMode(47, GPIO_DIR_MODE_IN);

    //
    // Configure the Power Fault.
    //
    GPIO_setMasterCore(120, GPIO_CORE_CM);
    GPIO_setDirectionMode(120, GPIO_DIR_MODE_IN);

    //
    // Configure the External Power Signal Enable.
    //
    GPIO_setMasterCore(121, GPIO_CORE_CM);
	GPIO_setDirectionMode(121, GPIO_DIR_MODE_OUT);
	GPIO_writePin(121, 1);

    //
    // Set the CM Clock to run at 120MHz.
    // The CM Clock is a fractional multiple of the AUXPLL Clock (120 Mhz) from
    // which the USB Clock (60 MHz) is derived.
    //
    SysCtl_setCMClk(SYSCTL_CMCLKOUT_DIV_1, SYSCTL_SOURCE_AUXPLL);
#endif
}

//###########################################################################
//
// FILE:   enet_lwip.c
//
// TITLE:  lwIP based Ethernet Example.
//
//###########################################################################
// $TI Release: $
// $Release Date: $
// $Copyright: $
//###########################################################################

#include <string.h>

#include "inc/hw_ints.h"
#include "inc/hw_memmap.h"
#include "inc/hw_nvic.h"
#include "inc/hw_types.h"
#include "inc/hw_sysctl.h"
#include "inc/hw_emac.h"

#include "driverlib_cm/ethernet.h"
#include "driverlib_cm/gpio.h"
#include "driverlib_cm/interrupt.h"
#include "driverlib_cm/flash.h"

#include "driverlib_cm/sysctl.h"
#include "driverlib_cm/systick.h"

#include "utils/lwiplib.h"
#include "board_drivers/pinout.h"

#include "lwip/apps/httpd.h"
#include "ethernet.h"
#include "driverlib_cm.h"
//#include "ipc_cm.h"
//*****************************************************************************
//
//! \addtogroup master_example_list
//! <h1>Ethernet with lwIP (enet_lwip)</h1>
//!
//! This example application demonstrates the operation of the F2838x
//! microcontroller Ethernet controller using the lwIP TCP/IP Stack. Once
//! programmed, the device sits endlessly waiting for ICMP ping requests. It
//! has a static IP address. To ping the device, the sender has to be in the
//! same network. The stack also supports ARP.
//!
//! For additional details on lwIP, refer to the lwIP web page at:
//! savannah.nongnu.org/.../
//
//*****************************************************************************

// These are defined by the linker (see device linker command file)
extern uint16_t RamfuncsLoadStart;
extern uint16_t RamfuncsLoadSize;
extern uint16_t RamfuncsRunStart;
extern uint16_t RamfuncsLoadEnd;
extern uint16_t RamfuncsRunEnd;
extern uint16_t RamfuncsRunSize;

extern uint16_t constLoadStart;
extern uint16_t constLoadEnd;
extern uint16_t constLoadSize;
extern uint16_t constRunStart;
extern uint16_t constRunEnd;
extern uint16_t constRunSize;

#define DEVICE_FLASH_WAITSTATES 2

//*****************************************************************************
//
// Driver specific initialization code and macro.
//
//*****************************************************************************

#define ETHERNET_NO_OF_RX_PACKETS   2U
#define ETHERNET_MAX_PACKET_LENGTH 1538U
#define NUM_PACKET_DESC_RX_APPLICATION 16

Ethernet_Handle emac_handle;
Ethernet_InitConfig *pInitCfg;
uint32_t Ethernet_numRxCallbackCustom = 0;
uint32_t releaseTxCount = 0;
uint32_t genericISRCustomcount = 0;
uint32_t genericISRCustomRBUcount = 0;
uint32_t genericISRCustomROVcount = 0;
uint32_t genericISRCustomRIcount = 0;

uint32_t systickPeriodValue = 15000000;
Ethernet_Pkt_Desc  pktDescriptorRXCustom[NUM_PACKET_DESC_RX_APPLICATION];
extern uint32_t Ethernet_numGetPacketBufferCallback;
extern Ethernet_Device Ethernet_device_struct;
uint8_t Ethernet_rxBuffer[ETHERNET_NO_OF_RX_PACKETS *
                          ETHERNET_MAX_PACKET_LENGTH];
uint32_t sendPacketFailedCount = 0;

//
//******IPC*************
#define IPC_CMD_READ_MEM   0x1001
#define IPC_CMD_RESP       0x2001

#define TEST_PASS          0x5555
#define TEST_FAIL          0xAAAA
#define PACKET_LENGTH 132
#define ETHERNET_NO_OF_RX_PACKETS   1U
#define ETHERNET_MAX_PACKET_LENGTH 1538U
uint8_t pData[PACKET_LENGTH];
//uint8_t Ethernet_rxBuffer[ETHERNET_NO_OF_RX_PACKETS *ETHERNET_MAX_PACKET_LENGTH];
Ethernet_Handle emac_handle;
Ethernet_Pkt_Desc pktDesc;
extern uint32_t Ethernet_rxInterruptCount;
bool status = false;
//
//**********IPC******************
uint8_t mac_custom[6] = {0xA8, 0x63, 0xF2, 0x00, 0x1D, 0x98};

extern Ethernet_Pkt_Desc*
lwIPEthernetIntHandler(Ethernet_Pkt_Desc *pPacket);

void CM_init(void)
{
    //
    // Disable the watchdog
    //
    SysCtl_disableWatchdog();

#ifdef _FLASH
    //
    // Copy time critical code and flash setup code to RAM. This includes the
    // following functions: InitFlash();
    //
    // The RamfuncsLoadStart, RamfuncsLoadSize, and RamfuncsRunStart symbols
    // are created by the linker. Refer to the device .cmd file.
    // Html pages are also being copied from flash to ram.
    //
    memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
    memcpy(&constRunStart, &constLoadStart, (size_t)&constLoadSize);
    //
    // Call Flash Initialization to setup flash waitstates. This function must
    // reside in RAM.
    //
    Flash_initModule(FLASH0CTRL_BASE, FLASH0ECC_BASE, DEVICE_FLASH_WAITSTATES);
#endif

    //
    // Sets the NVIC vector table offset address.
    //
#ifdef _FLASH
    Interrupt_setVectorTableOffset((uint32_t)vectorTableFlash);
#else
    Interrupt_setVectorTableOffset((uint32_t)vectorTableRAM);
#endif

}
//*****************************************************************************
//
// HTTP Webserver related callbacks and definitions.
//
//*****************************************************************************
//
// Currently, this implemented as a pointer to function which is called when
// corresponding query is received by the HTTP webserver daemon. When more
// features are needed to be added, it should be implemented as a separate
// interface.
//
void httpLEDToggle(void);
void(*ledtoggleFuncPtr)(void) = &httpLEDToggle;

//*****************************************************************************
//
// The interrupt handler for the SysTick interrupt.
//
//*****************************************************************************
void
SysTickIntHandler(void)
{
    //
    // Call the lwIP timer handler.
    //
    lwIPTimer(systickPeriodValue);
}

//*****************************************************************************
//
//  This function is a callback function called by the example to
//  get a Packet Buffer. Has to return a ETHERNET_Pkt_Desc Structure.
//  Rewrite this API for custom use case.
//
//*****************************************************************************
Ethernet_Pkt_Desc* Ethernet_getPacketBufferCustom(void)
{
    //
    // Get the next packet descriptor from the descriptor pool
    //
    uint32_t shortIndex = (Ethernet_numGetPacketBufferCallback + 3)
                % NUM_PACKET_DESC_RX_APPLICATION;

    //
    // Increment the book-keeping pointer which acts as a head pointer
    // to the circular array of packet descriptor pool.
    //
    Ethernet_numGetPacketBufferCallback++;

    //
    // Update buffer length information to the newly procured packet
    // descriptor.
    //
    pktDescriptorRXCustom[shortIndex].bufferLength =
                                  ETHERNET_MAX_PACKET_LENGTH;

    //
    // Update the receive buffer address in the packer descriptor.
    //
    pktDescriptorRXCustom[shortIndex].dataBuffer =
                                      &Ethernet_device_struct.rxBuffer [ \
               (ETHERNET_MAX_PACKET_LENGTH*Ethernet_device_struct.rxBuffIndex)];

    //
    // Update the receive buffer pool index.
    //
    Ethernet_device_struct.rxBuffIndex += 1U;
    Ethernet_device_struct.rxBuffIndex  = \
    (Ethernet_device_struct.rxBuffIndex%ETHERNET_NO_OF_RX_PACKETS);

    //
    // Receive buffer is usable from Address 0
    //
    pktDescriptorRXCustom[shortIndex].dataOffset = 0U;

    //
    // Return this new descriptor to the driver.
    //
    return (&(pktDescriptorRXCustom[shortIndex]));
}

//*****************************************************************************
//
//  This is a hook function and called by the driver when it receives a
//  packet. Application is expected to replenish the buffer after consuming it.
//  Has to return a ETHERNET_Pkt_Desc Structure.
//  Rewrite this API for custom use case.
//
//*****************************************************************************
Ethernet_Pkt_Desc* Ethernet_receivePacketCallbackCustom(
        Ethernet_Handle handleApplication,
        Ethernet_Pkt_Desc *pPacket)
{
    //
    // Book-keeping to maintain number of callbacks received.
    //
#ifdef ETHERNET_DEBUG
    Ethernet_numRxCallbackCustom++;
#endif

    //
    // This is a placeholder for Application specific handling
    // We are replenishing the buffer received with another buffer
    //
    return lwIPEthernetIntHandler(pPacket);
}

void Ethernet_releaseTxPacketBufferCustom(
        Ethernet_Handle handleApplication,
        Ethernet_Pkt_Desc *pPacket)
{
    //
    // Once the packet is sent, reuse the packet memory to avoid
    // memory leaks. Call this interrupt handler function which will take care
    // of freeing the memory used by the packet descriptor.
    //
    lwIPEthernetIntHandler(pPacket);

    //
    // Increment the book-keeping counter.
    //
#ifdef ETHERNET_DEBUG
    releaseTxCount++;
#endif
}
Ethernet_Pkt_Desc *Ethernet_performPopOnPacketQueueCustom(
            Ethernet_PKT_Queue_T *pktQueuePtr)
{
    Ethernet_Pkt_Desc *pktDescHdrPtr;

    pktDescHdrPtr = pktQueuePtr->head;

    if(0U != pktDescHdrPtr)
    {
        pktQueuePtr->head = pktDescHdrPtr->nextPacketDesc;
        pktQueuePtr->count--;
    }

    return(pktDescHdrPtr);
}
void Ethernet_performPushOnPacketQueueCustom(
        Ethernet_PKT_Queue_T *pktQueuePtr,
        Ethernet_Pkt_Desc *pktDescHdrPtr)
{
    pktDescHdrPtr->nextPacketDesc = 0U;

    if(0U == pktQueuePtr->head)
    {
        //
        // Queue is empty - Initialize it with this one packet
        //
        pktQueuePtr->head = pktDescHdrPtr;
        pktQueuePtr->tail = pktDescHdrPtr;
    }
    else
    {
        //
        // Queue is not empty - Push onto END
        //
        pktQueuePtr->tail->nextPacketDesc = pktDescHdrPtr;
        pktQueuePtr->tail        = pktDescHdrPtr;
    }
    pktQueuePtr->count++;
}
void Ethernet_setMACConfigurationCustom(uint32_t base, uint32_t flags)
{
    HWREG(base + ETHERNET_O_MAC_CONFIGURATION) |= flags;
}
void Ethernet_clearMACConfigurationCustom(uint32_t base, uint32_t flags)
{
    HWREG(base + ETHERNET_O_MAC_CONFIGURATION) &= ~flags;

}
interrupt void Ethernet_genericISRCustom(void)
{
    genericISRCustomcount++;
    Ethernet_RxChDesc *rxChan;
    Ethernet_TxChDesc *txChan;
    Ethernet_HW_descriptor    *descPtr;
    Ethernet_HW_descriptor    *tailPtr;
    uint16_t i=0;
    Ethernet_clearMACConfigurationCustom(Ethernet_device_struct.baseAddresses.enet_base,ETHERNET_MAC_CONFIGURATION_RE);
    Ethernet_clearMACConfigurationCustom(Ethernet_device_struct.baseAddresses.enet_base,ETHERNET_MAC_CONFIGURATION_TE);
    for(i = 0U;i < Ethernet_device_struct.initConfig.numChannels;i++)
     {
         Ethernet_disableRxDMAReception(
               Ethernet_device_struct.baseAddresses.enet_base,
               i);
     }
    if(((ETHERNET_DMA_CH0_STATUS_AIS |
                         ETHERNET_DMA_CH0_STATUS_RBU) ==
                       (HWREG(Ethernet_device_struct.baseAddresses.enet_base +
                              ETHERNET_O_DMA_CH0_STATUS) &
                              (uint32_t)(ETHERNET_DMA_CH0_STATUS_AIS |
                                         ETHERNET_DMA_CH0_STATUS_RBU))) ||
          (ETHERNET_MTL_Q0_INTERRUPT_CONTROL_STATUS_RXOVFIS) ==
                                   (HWREG(Ethernet_device_struct.baseAddresses.enet_base +
                                          ETHERNET_O_MTL_Q0_INTERRUPT_CONTROL_STATUS) &
                                          (uint32_t)(ETHERNET_MTL_Q0_INTERRUPT_CONTROL_STATUS_RXOVFIS
                                                     )))
      {
          if((ETHERNET_DMA_CH0_STATUS_AIS |
                             ETHERNET_DMA_CH0_STATUS_RBU) ==
                           (HWREG(Ethernet_device_struct.baseAddresses.enet_base +
                                  ETHERNET_O_DMA_CH0_STATUS) &
                                  (uint32_t)(ETHERNET_DMA_CH0_STATUS_AIS |
                                             ETHERNET_DMA_CH0_STATUS_RBU)))
          {
          genericISRCustomRBUcount++;
          }
          if((ETHERNET_MTL_Q0_INTERRUPT_CONTROL_STATUS_RXOVFIS) ==
                  (HWREG(Ethernet_device_struct.baseAddresses.enet_base +
                         ETHERNET_O_MTL_Q0_INTERRUPT_CONTROL_STATUS) &
                         (uint32_t)(ETHERNET_MTL_Q0_INTERRUPT_CONTROL_STATUS_RXOVFIS
                                    )))
          {
              genericISRCustomROVcount++;
              Ethernet_enableMTLInterrupt(Ethernet_device_struct.baseAddresses.enet_base,0,
                                          ETHERNET_MTL_Q0_INTERRUPT_CONTROL_STATUS_RXOVFIS);
          }

        /*
             * Clear the AIS and RBU status bit. These MUST be
             * cleared together!
             */
            Ethernet_clearDMAChannelInterrupt(
                    Ethernet_device_struct.baseAddresses.enet_base,
                    ETHERNET_DMA_CHANNEL_NUM_0,
                    ETHERNET_DMA_CH0_STATUS_AIS |
                    ETHERNET_DMA_CH0_STATUS_RBU);

            /*
           *Recover from Receive Buffer Unavailable (and hung DMA)
         *
         * All descriptor buffers are owned by the application, and
         * in result the DMA cannot transfer incoming frames to the
         * buffers (RBU condition). DMA has also entered suspend
         * mode at this point, too.
         *
         * Drain the RX queues
         */

            /* Upon RBU error, discard all previously received packets */
            if(Ethernet_device_struct.initConfig.pfcbDeletePackets != NULL)
                (*Ethernet_device_struct.initConfig.pfcbDeletePackets)();

            rxChan =
               &Ethernet_device_struct.dmaObj.rxDma[ETHERNET_DMA_CHANNEL_NUM_0];
            txChan=
               &Ethernet_device_struct.dmaObj.txDma[ETHERNET_DMA_CHANNEL_NUM_0];

    /*
     * Need to disable multiple interrupts, so protect the code to do so within
     * a global disable block (to prevent getting interrupted in between)
     */

            if(NULL!= Ethernet_device_struct.ptrPlatformInterruptDisable)
            {
                (*Ethernet_device_struct.ptrPlatformInterruptDisable)(
                    Ethernet_device_struct.interruptNum[
                        ETHERNET_RX_INTR_CH0 + rxChan->chInfo->chNum]);

                (*Ethernet_device_struct.ptrPlatformInterruptDisable)(
                    Ethernet_device_struct.interruptNum[
                        ETHERNET_GENERIC_INTERRUPT]);
            }
            /* verify we have full capacity in the descriptor queue */
            if(rxChan->descQueue.count < rxChan->descMax) {
              /* The queue is not at full capacity due to OOM errors.
              Try to fill it again */
                Ethernet_addPacketsIntoRxQueue(rxChan);
            }
            Ethernet_initRxChannel(
                    &Ethernet_device_struct.initConfig.chInfo[ETHERNET_CH_DIR_RX][0]);

            Ethernet_writeRxDescTailPointer(
                Ethernet_device_struct.baseAddresses.enet_base,
                0,
                (&Ethernet_device_struct.rxDesc[
                 ((uint32_t)ETHERNET_DESCRIPTORS_NUM_RX_PER_CHANNEL) *
                  (0 + (uint32_t)1U)]));

            if(NULL!= Ethernet_device_struct.ptrPlatformInterruptEnable)
            {
                (*Ethernet_device_struct.ptrPlatformInterruptEnable)(
                    Ethernet_device_struct.interruptNum[
                        ETHERNET_RX_INTR_CH0 + rxChan->chInfo->chNum]);
                (*Ethernet_device_struct.ptrPlatformInterruptEnable)(
                    Ethernet_device_struct.interruptNum[
                        ETHERNET_GENERIC_INTERRUPT]);
            }


    }
    if(0U != (HWREG(Ethernet_device_struct.baseAddresses.enet_base +
                                 ETHERNET_O_DMA_CH0_STATUS) &
                           (uint32_t) ETHERNET_DMA_CH0_STATUS_RI))
    {
        genericISRCustomRIcount++;
        Ethernet_clearDMAChannelInterrupt(
                        Ethernet_device_struct.baseAddresses.enet_base,
                        ETHERNET_DMA_CHANNEL_NUM_0,
                        ETHERNET_DMA_CH0_STATUS_NIS | ETHERNET_DMA_CH0_STATUS_RI);
    }

    for(i = 0U;i < Ethernet_device_struct.initConfig.numChannels;i++)
     {
         Ethernet_enableRxDMAReception(
               Ethernet_device_struct.baseAddresses.enet_base,
               i);
     }
    Ethernet_setMACConfigurationCustom(Ethernet_device_struct.baseAddresses.enet_base,ETHERNET_MAC_CONFIGURATION_RE);
    Ethernet_setMACConfigurationCustom(Ethernet_device_struct.baseAddresses.enet_base,ETHERNET_MAC_CONFIGURATION_TE);
}

void
Ethernet_init(const unsigned char *mac)
{
    Ethernet_InitInterfaceConfig initInterfaceConfig;
    uint32_t macLower;
    uint32_t macHigher;
    uint8_t *temp;

    initInterfaceConfig.ssbase = EMAC_SS_BASE;
    initInterfaceConfig.enet_base = EMAC_BASE;
    initInterfaceConfig.phyMode = ETHERNET_SS_PHY_INTF_SEL_MII;

    //
    // Assign SoC specific functions for Enabling,Disabling interrupts
    // and for enabling the Peripheral at system level
    //
    initInterfaceConfig.ptrPlatformInterruptDisable =
                                                    &Platform_disableInterrupt;
    initInterfaceConfig.ptrPlatformInterruptEnable =
                                                     &Platform_enableInterrupt;
    initInterfaceConfig.ptrPlatformPeripheralEnable =
                                                    &Platform_enablePeripheral;
    initInterfaceConfig.ptrPlatformPeripheralReset =
                                                     &Platform_resetPeripheral;

    //
    // Assign the peripheral number at the SoC
    //
    initInterfaceConfig.peripheralNum = SYSCTL_PERIPH_CLK_ENET;

    //
    // Assign the default SoC specific interrupt numbers of Ethernet interrupts
    //
    initInterfaceConfig.interruptNum[0] = INT_EMAC;
    initInterfaceConfig.interruptNum[1] = INT_EMAC_TX0;
    initInterfaceConfig.interruptNum[2] = INT_EMAC_TX1;
    initInterfaceConfig.interruptNum[3] = INT_EMAC_RX0;
    initInterfaceConfig.interruptNum[4] = INT_EMAC_RX1;

    pInitCfg = Ethernet_initInterface(initInterfaceConfig);

    Ethernet_getInitConfig(pInitCfg);
    pInitCfg->dmaMode.InterruptMode = ETHERNET_DMA_MODE_INTM_MODE2;

    //
    // Assign the callbacks for Getting packet buffer when needed
    // Releasing the TxPacketBuffer on Transmit interrupt callbacks
    // Receive packet callback on Receive packet completion interrupt
    //
    pInitCfg->pfcbRxPacket = &Ethernet_receivePacketCallbackCustom;
    pInitCfg->pfcbGetPacket = &Ethernet_getPacketBuffer;
    pInitCfg->pfcbFreePacket = &Ethernet_releaseTxPacketBufferCustom;

    //
    //Assign the Buffer to be used by the Low level driver for receiving
    //Packets. This should be accessible by the Ethernet DMA
    //
    pInitCfg->rxBuffer = Ethernet_rxBuffer;

    //
    // The Application handle is not used by this application
    // Hence using a dummy value of 1
    //
    Ethernet_getHandle((Ethernet_Handle)1, pInitCfg , &emac_handle);

    //
    // Disable transmit buffer unavailable and normal interrupt which
    // are enabled by default in Ethernet_getHandle.
    //
    Ethernet_disableDmaInterrupt(Ethernet_device_struct.baseAddresses.enet_base,
                                 0, (ETHERNET_DMA_CH0_INTERRUPT_ENABLE_TBUE |
                                     ETHERNET_DMA_CH0_INTERRUPT_ENABLE_NIE));

    //
    // Enable the MTL interrupt to service the receive FIFO overflow
    // condition in the Ethernet module.
    //
    Ethernet_enableMTLInterrupt(Ethernet_device_struct.baseAddresses.enet_base,0,
                                ETHERNET_MTL_Q0_INTERRUPT_CONTROL_STATUS_RXOIE);

    //
    // Disable the MAC Management counter interrupts as they are not used
    // in this application.
    //
    HWREG(Ethernet_device_struct.baseAddresses.enet_base + ETHERNET_O_MMC_RX_INTERRUPT_MASK) = 0xFFFFFFFF;
    HWREG(Ethernet_device_struct.baseAddresses.enet_base + ETHERNET_O_MMC_IPC_RX_INTERRUPT_MASK) = 0xFFFFFFFF;
    //
    //Do global Interrupt Enable
    //
    (void)Interrupt_enableInProcessor();

    //
    //Assign default ISRs
    //
    Interrupt_registerHandler(INT_EMAC_TX0, Ethernet_transmitISR);
    Interrupt_registerHandler(INT_EMAC_RX0, Ethernet_receiveISR);
    Interrupt_registerHandler(INT_EMAC, Ethernet_genericISRCustom);

    //
    //Enable the default interrupt handlers
    //
    Interrupt_enable(INT_EMAC_TX0);
    Interrupt_enable(INT_EMAC_RX0);
    Interrupt_enable(INT_EMAC);

    //
    // Convert the mac address string into the 32/16 split variables format
    // that is required by the driver to program into hardware registers.
    // Note: This step is done after the Ethernet_getHandle function because
    //       a dummy MAC address is programmed in that function.
    //
    temp = (uint8_t *)&macLower;
    temp[0] = mac[0];
    temp[1] = mac[1];
    temp[2] = mac[2];
    temp[3] = mac[3];

    temp = (uint8_t *)&macHigher;
    temp[0] = mac[4];
    temp[1] = mac[5];

    //
    // Program the unicast mac address.
    //
    Ethernet_setMACAddr(EMAC_BASE,
                        0,
                        macHigher,
                        macLower,
                        ETHERNET_CHANNEL_0);
    Ethernet_clearMACConfigurationCustom(Ethernet_device_struct.baseAddresses.enet_base,ETHERNET_MAC_CONFIGURATION_RE);
    Ethernet_setMACConfigurationCustom(Ethernet_device_struct.baseAddresses.enet_base,ETHERNET_MAC_CONFIGURATION_RE);
}
//********************IPC******************
void IPC_ISR0()
{
    uint32_t command, addr, data;
    //
    // Read the command
    //
    IPC_readCommand(IPC_CM_L_CPU1_R, IPC_FLAG0, IPC_ADDR_CORRECTION_ENABLE,
                    &command, &addr, &data);


    if(command == IPC_CMD_READ_MEM)
    {
        status = true;
        //
        //Read the buffer address and Length
        //from the IPC message从IPC信息中读取缓存地址和长度
        //
        pktDesc.dataBuffer = (uint8_t *)addr;
        pktDesc.bufferLength = data;
        pktDesc.pktLength = data;
        pktDesc.validLength = data;
        //
        //Send the packet on receiving Message from C28x side
        //
        Ethernet_sendPacket(emac_handle,&pktDesc);
    }
}

//********************IPC******************

//*****************************************************************************
//
// This example demonstrates the use of the Ethernet Controller.
//
//*****************************************************************************
int
main(void)
{
    unsigned long ulUser0, ulUser1;
    unsigned char pucMACArray[8];

    //
    // User specific IP Address Configuration.
    // Current implementation works with Static IP address only.
    //
    unsigned long IPAddr = 0xC0A80004;
    unsigned long NetMask = 0xFFFFFF00;
    unsigned long GWAddr = 0x00000000;

    //
    // Initializing the CM. Loading the required functions to SRAM.
    //
    CM_init();

    SYSTICK_setPeriod(systickPeriodValue);
    SYSTICK_enableCounter();
    SYSTICK_registerInterruptHandler(SysTickIntHandler);
    SYSTICK_enableInterrupt();
    //******************************IPC_CM******************************
        Ethernet_InitInterfaceConfig initInterfaceConfig;
        Ethernet_InitConfig *pInitCfg;
        //
        //Select the MII interface of the module
        //选择模块的MII接口
        initInterfaceConfig.ssbase = EMAC_SS_BASE;
        initInterfaceConfig.enet_base = EMAC_BASE;
        initInterfaceConfig.phyMode = ETHERNET_SS_PHY_INTF_SEL_MII;
        //
        //Assign SoC specific functions for Enabling,Disabling interrupts
        //and for enabling the Peripheral at system level
        //分配SoC特定功能以启用，禁用中断以及在系统级别启用外围设备
        initInterfaceConfig.ptrPlatformInterruptDisable = &Platform_disableInterrupt;
        initInterfaceConfig.ptrPlatformInterruptEnable = &Platform_enableInterrupt;
        initInterfaceConfig.ptrPlatformPeripheralEnable = &Platform_enablePeripheral;
        initInterfaceConfig.ptrPlatformPeripheralReset = &Platform_resetPeripheral;
        //
        //Assign the peripheral number at the SoC
        //在SoC上分配外围设备号
        initInterfaceConfig.peripheralNum = SYSCTL_PERIPH_CLK_ENET;
        //
        //Assign the default SoC specific interrupt numbers of Ethernet interrupts
        //分配以太网中断的默认SoC特定中断号
        initInterfaceConfig.interruptNum[0] = INT_EMAC;
        initInterfaceConfig.interruptNum[1] = INT_EMAC_TX0;
        initInterfaceConfig.interruptNum[2] = INT_EMAC_TX1;
        initInterfaceConfig.interruptNum[3] = INT_EMAC_RX0;
        initInterfaceConfig.interruptNum[4] = INT_EMAC_RX1;

        pInitCfg = Ethernet_initInterface(initInterfaceConfig);

        //
        // Get an initial configuration of known good parameters
        //获取已知良好参数的初始配置
        Ethernet_getInitConfig(pInitCfg);

        //
        //Configure the Loopback mode
        //配置环回模式
        pInitCfg->loopbackMode = ETHERNET_MAC_CONFIGURATION_LM_LOOPBACK_DISABLED;        //***********************禁用回环模式**********************

        //
        //Assign the callbacks for Getting packet buffer when needed
        //Releasing the TxPacketBuffer on Transmit interrupt callbacks
        //Receive packet callback on Receive packet completion interrupt
        //在需要时分配用于获取数据包缓冲区的回调在发送中断回调上释放TxPacketBuffer在接收数据包完成中断时接收数据包回调
        pInitCfg->pfcbGetPacket = &Ethernet_getPacketBuffer;
        pInitCfg->pfcbFreePacket = &Ethernet_releaseTxPacketBuffer;
        pInitCfg->pfcbRxPacket = &Ethernet_receivePacketCallback;
        //
        //Assign the Buffer to be used by the Low level driver for receiving
        //Packets. This should be accessible by the Ethernet DMA
        //分配要由低级驱动程序用于接收数据包的缓冲区。 这应该可以通过以太网DMA访问
        pInitCfg->rxBuffer = Ethernet_rxBuffer;

        //
        //The Application handle is not used by this application
        //Hence using a dummy value of 1
        //此应用程序未使用应用程序句柄，因此使用虚拟值1
        Ethernet_getHandle((Ethernet_Handle)1,pInitCfg , &emac_handle);

    //******************************IPC_CM*********************************


    //
    // Enable processor interrupts.
    //
    Interrupt_enableInProcessor();
        
    // Set user/company specific MAC octets
    // (for this code we are using A8-63-F2-00-00-80)
    // 0x00 MACOCT3 MACOCT2 MACOCT1
    ulUser0 = 0x00F263A8;

    // 0x00 MACOCT6 MACOCT5 MACOCT4
    ulUser1 = 0x00800000;

    //
    // Convert the 24/24 split MAC address from NV ram into a 32/16 split MAC
    // address needed to program the hardware registers, then program the MAC
    // address into the Ethernet Controller registers.
    //
    pucMACArray[0] = ((ulUser0 >>  0) & 0xff);
    pucMACArray[1] = ((ulUser0 >>  8) & 0xff);
    pucMACArray[2] = ((ulUser0 >> 16) & 0xff);
    pucMACArray[3] = ((ulUser1 >>  0) & 0xff);
    pucMACArray[4] = ((ulUser1 >>  8) & 0xff);
    pucMACArray[5] = ((ulUser1 >> 16) & 0xff);

    //
    // Initialize ethernet module.
    //
    Ethernet_init(mac_custom);

    //
    // Initialze the lwIP library, using DHCP.
    //
    lwIPInit(0, mac_custom, IPAddr, NetMask, GWAddr, IPADDR_USE_STATIC);

    //
    // Initialize the HTTP webserver daemon.
    //
    httpd_init();
    //**********************IPC_CM***********************************
        //Assign default ISRs
        //分配默认ISR
        Interrupt_registerHandler(INT_EMAC_TX0, Ethernet_transmitISR);
        Interrupt_registerHandler(INT_EMAC_RX0, Ethernet_receiveISR);
        //
        //Enable the default interrupt handlers
        //启用默认的中断处理程序
        Interrupt_enable(INT_EMAC_TX0);
        Interrupt_enable(INT_EMAC_RX0);

        //
        //Prepare a Packet Descriptor structure to send a packet
        //This contains a single buffer packet
        //The Source address shall be inserted by the MAC
        //Packet CRC is auto computed by the module and appended in the packet
        //准备一个数据包描述符结构以发送一个数据包，其中包含一个缓冲数据包
        //源地址应由MAC数据包插入CRC由模块自动计算并附加在数据包中

        pktDesc.dataOffset = 0;
        pktDesc.nextPacketDesc = 0;
        pktDesc.flags = ETHERNET_PKT_FLAG_SOP |ETHERNET_PKT_FLAG_EOP|ETHERNET_PKT_FLAG_SA_INS;
        pktDesc.pktChannel = ETHERNET_DMA_CHANNEL_NUM_0;

        pktDesc.numPktFrags = 1;

        //
        // Clear any IPC flags if set already
        //清除所有IPC标志（如果已设置）
        IPC_clearFlagLtoR(IPC_CM_L_CPU1_R, IPC_FLAG_ALL);

        //
        // Enable IPC interrupts
        //启用IPC中断
        IPC_registerInterrupt(IPC_CM_L_CPU1_R, IPC_INT0, IPC_ISR0);

        //
        // Synchronize both the cores.
        //同步两个内核。
        IPC_sync(IPC_CM_L_CPU1_R, IPC_FLAG31);

        //
        //At this point the C28x core shall send IPC command
        //which triggers the IPC ISR where the packet is sent
        //With internal loopback the packet is looped back
        //Wait for the packet to be received
        //此时，C28x内核将发送IPC命令，该命令将触发IPC ISR，在该IPC ISR上发送数据包。

        while(0 == Ethernet_rxInterruptCount);

        //
        //The control data to C28x side can be picked up from Ethernet buffer and
        //Passed to Ethernet
        //可以从以太网缓冲区中提取到C28x侧的控制数据，并传递给以太网
        // Send response to C28x core
        //发送响应到C28x内核
        if(status)
        {
            IPC_sendResponse(IPC_CM_L_CPU1_R, TEST_PASS);
        }
        else
        {
            IPC_sendResponse(IPC_CM_L_CPU1_R, TEST_FAIL);
        }

        //
        // Acknowledge the flag
        //确认标志
        IPC_ackFlagRtoL(IPC_CM_L_CPU1_R, IPC_FLAG0);

        __asm("   bkpt #0");


    //**********************IPC_CM************************************
    //
    // Loop forever. All the work is done in interrupt handlers.
    //
    while(1);
}

//*****************************************************************************
//
// Called by lwIP Library. Toggles the led when a command is received by the
// HTTP webserver.
//
//*****************************************************************************
void httpLEDToggle(void)
{
    //
    // Toggle the LED D1 on the control card.
    //
    GPIO_togglePin(DEVICE_GPIO_PIN_LED1);
}


//*****************************************************************************
//
// Called by lwIP Library. Could be used for periodic custom tasks.
//
//*****************************************************************************
void lwIPHostTimerHandler(void)
{

}

谢谢

Vince

您好，Yashwant Temburu

你好。 在我的一侧、我尝试调节、但我有点困惑、我不知道如何将数据放入其中并传输数据。

谢谢

Vince

当您说它达到 ASM bpktt 时、这是不正确的。 您的 CM4正在确认 IPC 请求、并完成其等待过程。  

为了 更好地理解 IPC、您可能需要参考 IPC 示例 C2000Ware_3_04_00_00\driverlib\f2838x\examples\C28x_cm\IPC。

此外、还将 IPC 专家添加到线程中。 您可能需要等待 IPC 专家的回复。

-yashwant

您好，Yashwant Temburu

好的、让我们不要考虑 IPC 问题。
我现在只有一个问题。 数据通过 IPC 发送到 CM4内核后、CM4内核如何驱动以太网将数据发送到笔记本电脑。 同时、笔记本电脑如何接收这些数据并完全显示这些数据。
这是我唯一的问题。 这个问题困扰了我半个月。 我希望它能帮助我解决这个问题。

谢谢

Vince

如何通过 TCP/IP 在两个设备之间通信数据是一个完全独立的问题、与设备无关。

首先，您可以在  enet_lwip 示例中查看 lwIP API tcp_output()、tcp_new()。   使用  tcp_new()正确配置协议控制块的远程 IP 地址和设备 IP 地址后 ，您可以使用指向要发送的所需数据的新 pbuf 来更新 PCB 的数据指针。 然后，您可以调用  tcp_output() ，将该 PCB 作为一个参数传递，该参数将使用 f2838x 接口层将数据发送到网络。

对于笔记本电脑中的主机端、您可以使用  python 套接 字封装等工具来发送或接收数据包、或者仅使用 Wireshark 来接入网络以检查是否接收到数据。

您的问题过于笼统、无法在本论坛中回答。 请尝试参阅一些有关基于 TCP/IP 或 UDP 的通信或一些开源解决方案的书籍。

此致、

Yashwant