void SendIP4Package(ip_addr_t DstIPAddress, u8 *Payload, int PayloadLength, u8 Protocol) { u8 PackageBuffer[XEL_MAX_FRAME_SIZE - XEL_HEADER_SIZE]; int i = 0; IP4Header_t ip4_header; ip4_header.VerIHL = 0x45; // ToDo make dynamic ip4_header.TypeOfService = 0x00; // ToDo make configurable through user ip4_header.TotalLength = 20 + PayloadLength; ip4_header.Identification = 0x0000; ip4_header.FlagsFragOffset = 0x0000; ip4_header.Protocol = Protocol; ip4_header.TTL = 0x80; ip4_header.HeaderChksm = 0x0000; // ToDo Calc Checksum ip4_header.DstAddr = DstIPAddress; ip4_header.SrcAddr = LocalAddr; u8 *HeaderPtr = (u8 *)&ip4_header; u8 *PackagePtr; PackagePtr = (u8 *)PackageBuffer; for (i = 0; i < 20; i++) { *PackagePtr++ = HeaderPtr[i]; } for (i = 0; i < PayloadLength; i++) { *PackagePtr++ = Payload[i]; } EmacLiteSendFrame((u8 *)PackageBuffer, 20 + PayloadLength, &RemoteMacAddr, 0x0800); }
/*-----------------------------------------------------------*/ static void prvRxTask( void *pvParameters ) { char Recdstring[15] = ""; int i; int Status; u32 prev_btns = 0; /* Print the received data. */ xil_printf( "Rx task starting.\r\n"); for( ;; ) { RecvFrameLength = 0; /* * Poll for receive packet. */ while ((volatile u32)RecvFrameLength == 0) { vTaskDelay(1); u32 btns = XGpio_DiscreteRead(&gpio_btns, 1); if (btns != prev_btns) { xil_printf("btns=%d\r\n", btns); if (btns == 1) { /* send a frame */ xil_printf( "Rx emac: sending a frame\r\n"); Status = EmacLiteSendFrame(&emac, 128); if (Status != XST_SUCCESS) { xil_printf( "Rx emac: send frame fail\r\n"); } } prev_btns = btns; } RecvFrameLength = XEmacLite_Recv(&emac, (u8 *)RxFrame); } xil_printf( "Rx emac: frame recv, len=%d\r\n", RecvFrameLength); /* * Check the received frame. */ Status = EmacLiteRecvFrame(128); if ((Status != XST_SUCCESS) && (Status != XST_NO_DATA)) { xil_printf( "Rx emac: frame rx check no success\r\n"); } for (i = 0; i < RecvFrameLength; ++i) { xil_printf("%02x:", RxFrame[i]); } xil_printf("\r\n"); } }
/** * * The main entry point for the EmacLite driver example in polled mode. * * This function will transmit/receive the Ethernet frames and verify the * data in the received frame (if the MDIO interface is configured in the * EmacLite core). * This function simply transmits a frame if the MDIO interface is not * configured in the EmacLite core. * * @param DeviceId is device ID of the XEmacLite Device , typically * XPAR_<EMAC_instance>_DEVICE_ID value from xparameters.h. * * @return XST_SUCCESS to indicate success, XST_FAILURE otherwise. * * @note None. * ******************************************************************************/ int EmacLitePolledExample(u16 DeviceId) { int Status; XEmacLite *EmacLiteInstPtr = &EmacLiteInstance; u32 PhyAddress = 0; RecvFrameLength = 0; XEmacLite_Config *ConfigPtr; /* * Initialize the EmacLite device. */ ConfigPtr = XEmacLite_LookupConfig(DeviceId); if (ConfigPtr == NULL) { return XST_FAILURE; } Status = XEmacLite_CfgInitialize(EmacLiteInstPtr, ConfigPtr, ConfigPtr->BaseAddress); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Set the MAC address. */ XEmacLite_SetMacAddress(EmacLiteInstPtr, LocalAddress); /* * Empty any existing receive frames. */ XEmacLite_FlushReceive(EmacLiteInstPtr); /* * Check if there is a TX buffer available, if there isn't it is an * error. */ if (XEmacLite_TxBufferAvailable(EmacLiteInstPtr) != TRUE) { return XST_FAILURE; } /* * If the MDIO is configured in the device. */ if (XEmacLite_IsMdioConfigured(EmacLiteInstPtr)) { /* * Detect the PHY device and enable the MAC Loop back * in the PHY. */ PhyAddress = EmacLitePhyDetect(EmacLiteInstPtr); Status = EmacLiteEnablePhyLoopBack(EmacLiteInstPtr, PhyAddress); if (Status != XST_SUCCESS) { return XST_FAILURE; } } /* * Reset the receive frame length to zero. */ RecvFrameLength = 0; Status = EmacLiteSendFrame(EmacLiteInstPtr, EMACLITE_TEST_FRAME_SIZE); if (Status != XST_SUCCESS) { if (XEmacLite_IsMdioConfigured(EmacLiteInstPtr)) { /* * Disable the MAC Loop back in the PHY. */ EmacLiteDisablePhyLoopBack(EmacLiteInstPtr, PhyAddress); return XST_FAILURE; } } /* * If the MDIO is not configured in the core then return XST_SUCCESS * as the frame has been transmitted. */ if (!XEmacLite_IsMdioConfigured(EmacLiteInstPtr)) { return XST_SUCCESS; } /* * Poll for receive packet. */ while ((volatile u32)RecvFrameLength == 0) { RecvFrameLength = XEmacLite_Recv(EmacLiteInstPtr, (u8 *)RxFrame); } /* * Check the received frame. */ Status = EmacLiteRecvFrame(EMACLITE_TEST_FRAME_SIZE); if ((Status != XST_SUCCESS) && (Status != XST_NO_DATA)) { /* * Disable the MAC Loop back in the PHY. */ EmacLiteDisablePhyLoopBack(EmacLiteInstPtr, PhyAddress); return XST_FAILURE; } /* * Disable the MAC Loop back in the PHY. */ EmacLiteDisablePhyLoopBack(EmacLiteInstPtr, PhyAddress); return XST_SUCCESS; }
int main() { static XIntc intc; Xil_ICacheEnable(); Xil_DCacheEnable(); xil_printf("Testing UART output.\r\n"); // Camera DMA Configuration XAxiDma_Config *dmaconf = XAxiDma_LookupConfig(XPAR_AXI_DMA_0_DEVICE_ID); XAxiDma dma; XAxiDma_CfgInitialize(&dma, dmaconf); XAxiDma_Resume(&dma); XAxiDma_Reset(&dma); while(!XAxiDma_ResetIsDone(&dma)); // Initialize Video InitVideo(); // Example camera DMA read // Note - transfer MUST be 4096B // Data format is 20-bit pixel number (stored in a 32 bit integer) followed by 16-bit RGB values // This will not work until you implement camera_stream.v. // (or at least, until you have it barely working) //int resdde = XAxiDma_SimpleTransfer(&dma, (u32)((unsigned char*)&camera), 4096, XAXIDMA_DEVICE_TO_DMA); //while(XAxiDma_Busy(&dma,XAXIDMA_DEVICE_TO_DMA)); int Status; XEmacLite *EmacLiteInstPtr = &EmacLiteInstance; u32 PhyAddress = 0; RecvFrameLength = 0; XEmacLite_Config *ConfigPtr; /* * Initialize the EmacLite device. */ ConfigPtr = XEmacLite_LookupConfig(XPAR_ETHERNET_LITE_DEVICE_ID); if (ConfigPtr == NULL) { return XST_FAILURE; } Status = XEmacLite_CfgInitialize(EmacLiteInstPtr, ConfigPtr, ConfigPtr->BaseAddress); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Set the MAC address. */ XEmacLite_SetMacAddress(EmacLiteInstPtr, LocalAddress); /* * Empty any existing receive frames. */ XEmacLite_FlushReceive(EmacLiteInstPtr); /* * Check if there is a TX buffer available, if there isn't it is an * error. */ if (XEmacLite_TxBufferAvailable(EmacLiteInstPtr) != TRUE) { return XST_FAILURE; } /* * Reset the receive frame length to zero. */ RecvFrameLength = 0; // Example program that sends packets and changes the color of an on-screen box upon receiving a packet. unsigned char c = 0; unsigned char r=0xFF, g=0x0, b=0x0; while(1) { c++; if(XEmacLite_IsTxDone(ConfigPtr->BaseAddress)) { Status = EmacLiteSendFrame(EmacLiteInstPtr, EMACLITE_TEST_FRAME_SIZE); if (Status != XST_SUCCESS) { if (XEmacLite_IsMdioConfigured(EmacLiteInstPtr)) { return XST_FAILURE; } } } else { RecvFrameLength = XEmacLite_Recv(EmacLiteInstPtr, (u8 *)RxFrame); if (RecvFrameLength > 0) { xil_printf("Received a packet!\r\n"); unsigned char oldr = r; r=g; g=b; b=oldr; } // Example of writing data to the screen int x, y; for (x = 0; x < 20; x++) for (y = 0; y < 20; y++) if (t[y*20 + x]) { fptr[y*640*4 + x*4] = b; fptr[y*640*4 + x*4 + 1] = g; fptr[y*640*4 + x*4 + 2] = r; } } } Xil_DCacheDisable(); Xil_ICacheDisable(); return 0; }
/** * * The main entry point for the EmacLite driver in interrupt mode example. * This function will transmit/receive the frame using internal loop back and * verify the data in the received frame. * * @param DeviceId is device ID of the XEmacLite Device , typically * XPAR_<EMAC_instance>_DEVICE_ID value from xparameters.h. * * @return XST_SUCCESS to indicate success, otherwise XST_FAILURE. * * @note None. * ******************************************************************************/ int EmacLiteIntrLoopbackExample(u16 DeviceId) { int Status; XIntc *IntcInstancePtr; XEmacLite *EmacLiteInstPtr; u32 TxLength; XEmacLite_Config *ConfigPtr; RecvFrameLength = 0; IntcInstancePtr = &IntcInstance; EmacLiteInstPtr =&EmacLiteInstance; /* * Initialize the EmacLite device. */ ConfigPtr = XEmacLite_LookupConfig(DeviceId); if (ConfigPtr == NULL) { return XST_FAILURE; } Status = XEmacLite_CfgInitialize(EmacLiteInstPtr, ConfigPtr, ConfigPtr->BaseAddress); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Set the MAC address. */ XEmacLite_SetMacAddress(EmacLiteInstPtr, LocalAddress); /* * Set up the interrupt infrastructure. */ Status = EmacLiteSetupIntrSystem(IntcInstancePtr, EmacLiteInstPtr, INTC_EMACLITE_ID); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Setup the EmacLite handlers. */ XEmacLite_SetRecvHandler((EmacLiteInstPtr), (void *)(EmacLiteInstPtr), (XEmacLite_Handler)EmacLiteRecvHandler); XEmacLite_SetSendHandler((EmacLiteInstPtr), (void *)(EmacLiteInstPtr), (XEmacLite_Handler)EmacLiteSendHandler); /* * Empty any existing receive frames. */ XEmacLite_FlushReceive(EmacLiteInstPtr); /* * Enable the EmacLite interrupts. */ XEmacLite_EnableInterrupts(EmacLiteInstPtr); /* * Check if there is a Tx buffer available. */ if (XEmacLite_TxBufferAvailable(EmacLiteInstPtr) != TRUE) { return XST_FAILURE; } /* * Enable internal loop back. */ XEmacLite_EnableLoopBack(EmacLiteInstPtr); /* * Send/Receive frames of varying sizes and verify the data in the * received frames. */ for (TxLength = 1; TxLength <= XEL_MTU_SIZE; ) { RecvFrameLength = 0; /* * Send a frame. */ Status = EmacLiteSendFrame(EmacLiteInstPtr, TxLength); if (Status != XST_SUCCESS) { /* * Disable internal loop back. */ XEmacLite_DisableLoopBack(EmacLiteInstPtr); return XST_FAILURE; } /* * Wait for the frame to be transmitted and received back. * As the core is in loopback the transmit interrupt and the * receive interrupt occur simulataneously. */ while ((RecvFrameLength == 0) && (TransmitComplete == FALSE)); /* * Check the receive frame. */ Status = EmacLiteRecvFrame(TxLength++); if ((Status != XST_SUCCESS) && (Status != XST_NO_DATA)) { /* * Disable internal loop back. */ XEmacLite_DisableLoopBack(EmacLiteInstPtr); /* * Disable and disconnect the EmacLite Interrupts. */ XEmacLite_DisableInterrupts(EmacLiteInstPtr); EmacLiteDisableIntrSystem(IntcInstancePtr, INTC_EMACLITE_ID); return XST_FAILURE; } } /* * Disable internal loop back. */ XEmacLite_DisableLoopBack(EmacLiteInstPtr); /* * Disable and disconnect the EmacLite Interrupts. */ XEmacLite_DisableInterrupts(EmacLiteInstPtr); EmacLiteDisableIntrSystem(IntcInstancePtr, INTC_EMACLITE_ID); return XST_SUCCESS; }
/** * * The main entry point for the EmacLite driver example in interrupt mode. * This function will transmit/receive the Ethernet frames and verify the * data in the received frame (if the MDIO interface is configured in the * EmacLite core). * This function simply transmits a frame if the MDIO interface is not * configured in the EmacLite core. * * @param IntcInstancePtr is a pointer to the instance of the Intc. * @param EmacLiteInstPtr is a pointer to the instance of the EmacLite. * @param EmacLiteDeviceId is device ID of the XEmacLite Device , * typically XPAR_<EMACLITE_instance>_DEVICE_ID value from * xparameters.h. * @param EmacLiteIntrId is the interrupt ID and is typically * XPAR_<INTC_instance>_<EMACLITE_instance>_VEC_ID value from * xparameters.h. * * @return XST_SUCCESS if successful, otherwise XST_FAILURE. * * @note None. * ******************************************************************************/ int EmacLiteIntrExample(INTC *IntcInstancePtr, XEmacLite *EmacLiteInstPtr, u16 EmacLiteDeviceId, u16 EmacLiteIntrId) { int Status; u32 PhyAddress = 0; XEmacLite_Config *ConfigPtr; /* * Initialize the EmacLite device. */ ConfigPtr = XEmacLite_LookupConfig(EmacLiteDeviceId); if (ConfigPtr == NULL) { return XST_FAILURE; } Status = XEmacLite_CfgInitialize(EmacLiteInstPtr, ConfigPtr, ConfigPtr->BaseAddress); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Set the MAC address. */ XEmacLite_SetMacAddress(EmacLiteInstPtr, LocalAddress); /* * Empty any existing receive frames. */ XEmacLite_FlushReceive(EmacLiteInstPtr); /* * Check if there is a Tx buffer available, if there isn't it is an * error. */ if (XEmacLite_TxBufferAvailable(EmacLiteInstPtr) != TRUE) { return XST_FAILURE; } /* * Set up the interrupt infrastructure. */ Status = EmacLiteSetupIntrSystem(IntcInstancePtr, EmacLiteInstPtr, EmacLiteIntrId); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Setup the EmacLite handlers. */ XEmacLite_SetRecvHandler((EmacLiteInstPtr), (void *)(EmacLiteInstPtr), (XEmacLite_Handler)EmacLiteRecvHandler); XEmacLite_SetSendHandler((EmacLiteInstPtr), (void *)(EmacLiteInstPtr), (XEmacLite_Handler)EmacLiteSendHandler); /* * Enable the interrupts in the EmacLite controller. */ XEmacLite_EnableInterrupts(EmacLiteInstPtr); RecvFrameLength = 0; /* * If the MDIO is configured in the device. */ if (XEmacLite_IsMdioConfigured(EmacLiteInstPtr)) { /* * Detect the PHY device and enable the MAC Loop back * in the PHY. */ PhyAddress = EmacLitePhyDetect(EmacLiteInstPtr); Status = EmacLiteEnablePhyLoopBack(EmacLiteInstPtr, PhyAddress); if (Status != XST_SUCCESS) { XEmacLite_DisableInterrupts(EmacLiteInstPtr); EmacLiteDisableIntrSystem(IntcInstancePtr, EmacLiteIntrId); return XST_FAILURE; } } /* * Transmit an Ethernet frame. */ Status = EmacLiteSendFrame(EmacLiteInstPtr, EMACLITE_TEST_FRAME_SIZE); if (Status != XST_SUCCESS) { if (XEmacLite_IsMdioConfigured(EmacLiteInstPtr)) { /* * Disable the MAC Loop back in the PHY and * disable/disconnect the EmacLite Interrupts. */ EmacLiteDisablePhyLoopBack(EmacLiteInstPtr, PhyAddress); XEmacLite_DisableInterrupts(EmacLiteInstPtr); EmacLiteDisableIntrSystem(IntcInstancePtr, EmacLiteIntrId); return XST_FAILURE; } } /* * Wait for the frame to be transmitted. */ while (TransmitComplete == FALSE); /* * If the MDIO is not configured in the core then return XST_SUCCESS * as the frame has been transmitted. */ if (!XEmacLite_IsMdioConfigured(EmacLiteInstPtr)) { /* * Disable and disconnect the EmacLite Interrupts. */ XEmacLite_DisableInterrupts(EmacLiteInstPtr); EmacLiteDisableIntrSystem(IntcInstancePtr, EmacLiteIntrId); return XST_SUCCESS; } /* * Wait for the frame to be received. */ while (RecvFrameLength == 0); /* * Check the received frame. */ Status = EmacLiteRecvFrame(EMACLITE_TEST_FRAME_SIZE); /* * Diasble the Loop Back. */ if (XEmacLite_IsMdioConfigured(EmacLiteInstPtr)) { /* * Disable the MAC Loop back in the PHY. */ Status |= EmacLiteDisablePhyLoopBack(EmacLiteInstPtr, PhyAddress); } /* * Disable and disconnect the EmacLite Interrupts. */ XEmacLite_DisableInterrupts(EmacLiteInstPtr); EmacLiteDisableIntrSystem(IntcInstancePtr, EmacLiteIntrId); if ((Status != XST_SUCCESS) && (Status != XST_NO_DATA)) { return XST_FAILURE; } return XST_SUCCESS; }
/** * * The main entry point for the EmacLite driver in interrupt mode example. * * @param IntcInstancePtr is a pointer to the instance of the Intc. * @param EmacLiteInstPtr is a pointer to the instance of the EmacLite. * @param EmacLiteDeviceId is device ID of the XEmacLite Device , typically * XPAR_<EMACLITE_instance>_DEVICE_ID value from xparameters.h. * @param EmacLiteIntrId is the interrupt ID and is typically * XPAR_<INTC_instance>_<EMACLITE_instance>_IP2INTC_IRPT_INTR * value from xparameters.h. * * @return XST_SUCCESS if successful, otherwise XST_FAILURE. * * @note None. * ******************************************************************************/ XStatus EmacLiteExample(XIntc *IntcInstancePtr, XEmacLite *EmacLiteInstPtr, Xuint16 EmacLiteDeviceId, Xuint16 EmacLiteIntrId) { XStatus Status; /* * Initialize the EmacLite device. */ Status = XEmacLite_Initialize(EmacLiteInstPtr, EmacLiteDeviceId); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Set the MAC address. */ XEmacLite_SetMacAddress(EmacLiteInstPtr, LocalAddress); /* * Set up the interrupt infrastructure. */ Status = EmacLiteSetupIntrSystem(IntcInstancePtr, EmacLiteInstPtr, EmacLiteIntrId); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Setup the EmacLite handlers. */ XEmacLite_SetRecvHandler((EmacLiteInstPtr), (void *)(EmacLiteInstPtr), (XEmacLite_Handler) EmacLiteRecvHandler); XEmacLite_SetSendHandler((EmacLiteInstPtr), (void *)(EmacLiteInstPtr), (XEmacLite_Handler) EmacLiteSendHandler); /* * Empty any existing receive frames. */ XEmacLite_FlushReceive(EmacLiteInstPtr); /* * Enable the interrupts in the EmacLite controller. */ XEmacLite_EnableInterrupts(EmacLiteInstPtr); /* * Check if there is a Tx buffer available, if there isn't it is an error. */ if (XEmacLite_TxBufferAvailable(EmacLiteInstPtr) != XTRUE) { return XST_FAILURE; } /* * Transmit a ethernet frame. */ Status = EmacLiteSendFrame(EmacLiteInstPtr, EMACLITE_TEST_FRAME_SIZE, RemoteAddress); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Wait for the frame to be transmitted. */ while (TransmitComplete == XFALSE); /* * Disable and disconnect the EmacLite Interrupts. */ XEmacLite_DisableInterrupts(EmacLiteInstPtr); EmacLiteDisableIntrSystem(IntcInstancePtr, EmacLiteIntrId); return XST_SUCCESS; }