#include "xtime_l.h"
 
int main() {
    XTime startTime, endTime, executionTime;
 
	XTime_GetTime(&startTime);
	// Perform execution here
	XTime_GetTime(&endTime);
 
	executionTime = endTime - startTime;
    float timeInSecs = 1.0 * executionTime / COUNTS_PER_SECOND;
}

#include <stdio.h>
#include <xscutimer.h>

int main() {
	int i;
	XScuTimer timer;
	XScuTimer_Config *timercfg;

	timercfg = XScuTimer_LookupConfig(XPAR_SCUTIMER_DEVICE_ID);
	XScuTimer_CfgInitialize(&timer, timercfg, timercfg->BaseAddr);

	XScuTimer_LoadTimer(&timer, 500000000);
	XScuTimer_Start(&timer);

	for(i = 0; i < 10; i++) {
		printf("This is something which takes time.\n");
	}

	XScuTimer_Stop(&timer);
	int val = XScuTimer_GetCounterValue(&timer);

	printf("Timer value: %d\n", val);
	return 0;
}

#include <stdio.h>
#include <xscutimer.h>
#include <xil_exception.h>
#include <xscugic.h>

int count = 0;

void timer_callback(XScuTimer *timer) {
	printf("Beep %d\n", count++);
	XScuTimer_ClearInterruptStatus(timer);
}

int main() {
	XScuTimer timer;
	XScuTimer_Config *timercfg;

	timercfg = XScuTimer_LookupConfig(XPAR_SCUTIMER_DEVICE_ID);
	XScuTimer_CfgInitialize(&timer, timercfg, timercfg->BaseAddr);
	XScuTimer_EnableAutoReload(&timer);
	XScuTimer_LoadTimer(&timer, XPAR_CPU_CORTEXA9_0_CPU_CLK_FREQ_HZ);

	XScuGic_DeviceInitialize(XPAR_SCUGIC_SINGLE_DEVICE_ID);

	Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_IRQ_INT,
			(Xil_ExceptionHandler)XScuGic_DeviceInterruptHandler,
			(void *) XPAR_SCUGIC_SINGLE_DEVICE_ID);

	XScuGic_RegisterHandler(XPAR_SCUGIC_0_CPU_BASEADDR, XPAR_SCUTIMER_INTR,
			(Xil_ExceptionHandler) timer_callback,
			(void *) &timer);

	XScuGic_EnableIntr(XPAR_SCUGIC_0_DIST_BASEADDR, XPAR_SCUTIMER_INTR);
	Xil_ExceptionEnableMask(XIL_EXCEPTION_IRQ);
	XScuTimer_EnableInterrupt(&timer);
	XScuTimer_Start(&timer);

	//Create an infinite loop because the CPU shuts down when main() returns
	while(1);

	return 0;
}

#include <stdio.h>
#include "xparameters.h"
#include "platform.h"
#include "xil_printf.h"
#include "xil_cache.h"

void udp_get_handler(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) {
	// Check that a valid protocol control block was received
	if (p) { 
		// The message may not be zero terminated, so to ensure that we only 
		// print what was sent, we can create a zero-terminated copy and print that.
		char msg[p->len + 1];
		memcpy(msg, p->payload, p->len);
		msg[p->len] = '\0';
		
		printf("Message: %s\n", msg);
		
		// This is how we would send a reply back to the address which messaged us on port 7000
		//udp_sendto(pcb, p, addr, 7000);
		
		// Don't forget to free the packet buffer!
		pbuf_free(p);
	}
}

int main() {
	unsigned char mac_ethernet_address[] = {0x00, 0x11, 0x22, 0x33, 0x00, 0xXX}; // Put your own MAC address here!
	init_platform(mac_ethernet_address, NULL, NULL);
	
	struct udp_pcb *recv_pcb = udp_new();
	if (!recv_pcb) {
		printf("Error creating PCB\n");
	}
	
	// Listen on port 7001
	udp_bind(recv_pcb, IP_ADDR_ANY, 7001);
	// Set up the receive handler
	udp_recv(recv_pcb, udp_get_handler, NULL);
	
	// Send an initial message
	// Create a protocol control block (PCB)
	struct udp_pcb *send_pcb = udp_new();
	// Create a packet buffer and set the payload as the message
	struct pbuf * reply = pbuf_alloc(PBUF_TRANSPORT, strlen(message), PBUF_REF);
	reply->payload = message;
	reply->len = strlen(message);
	// Send the message
	ip_addr_t ip;
	IP4_ADDR(&ip, 192, 168, 9, 1);
	udp_sendto(send_pcb, reply, &ip, 8000);
	
	// Don't forget to free the packet buffer!
	pbuf_free(reply);
	
	// Remove the send PCB because we don't re-use it in this example
	udp_remove(send_pcb);
	
	// Now enter the handling loop
	while (1) {
		handle_ethernet();
	}
	return 0;
}

int main() {
	struct ip_addr ipaddr, netmask;
	IP4_ADDR(&ipaddr, 192, 168, 0, 30);
	IP4_ADDR(&netmask, 255, 255, 255, 0);
	unsigned char mac_ethernet_address[] = {0x00, 0x0a, 0x35, 0x00, 0x07, 0x02};
	init_platform(mac_ethernet_address, &ipaddr, &netmask);
	...
}

int sharedmemory[1000]; //Reserve 1000 integers (4000 bytes)
 
int main(void) {
	//Pass the address to the hardware.
	XToplevel_Set_ram(&hls, sharedmemory);
 
	//Rest of the application...
}

uint32 toplevel(uint32 *ram, uint32 arg1) {
	#pragma HLS INTERFACE m_axi port=ram offset=slave bundle=MAXI
	#pragma HLS INTERFACE s_axilite port=arg1 bundle=AXILiteS register
	#pragma HLS INTERFACE s_axilite port=return bundle=AXILiteS register
 
	ram[0] = 1234;
	ram[1] = 5678;
 
	//Or to bulk read/write memory we can use memcpy. eg. to write an array to RAM...
	int output[1000];
	memcpy(ram, output, 4000);
}

int sharedmemory[200]; //400 bytes of input, 400 bytes of output == 800 bytes, or 200 ints.

//Prepare input data
for(int i = 0; i < 100; i++) sharedmemory[i] = get_input_data(i);

//Run the IP core
XToplevel_Set_ram(&hls, sharedmemory);
XToplevel_Start(&hls);
while(!XToplevel_IsDone(&hls));

//sharedmemory[100] to sharedmemory[199] contains the output data

//-------------------------
//Meanwhile in HLS...

uint32 toplevel(uint32 *ram) {
	#pragma HLS INTERFACE m_axi port=ram offset=slave bundle=MAXI
	#pragma HLS INTERFACE s_axilite port=return bundle=AXILiteS register

	int mydata[100];
 
	//Read input data from ram[0-99] into our local cache mydata
	memcpy(mydata, ram, 400);

	//Do whatever we need to do
	processData(mydata);

	//Write mydata out to the return part of memory
	memcpy(ram+100, mydata, 400);
}

#include <string.h>
 
uint32 toplevel(uint32 *ram) {
	#pragma HLS INTERFACE m_axi port=ram offset=slave bundle=MAXI
	#pragma HLS INTERFACE s_axilite port=return bundle=AXILiteS register
 
	int datain[50];
 
	//Using individual reads
	for(int i = 0; i < 50; i++) {
		datain[i] = ram[i];
	}
 
	//Using memcpy
	memcpy(datain, ram, 50 * sizeof(int));
}

#include <xil_cache.h>
 
int shared[1000];

int main() {
	//Write to shared
	...
 

	//Force the writes to main memory
	Xil_DCacheFlush();
	//or alternatively Xil_DCacheFlushRange((INTPTR) shared, sizeof(shared));
 
	//Start the HLS component
	XToplevel_Start(&hls);
    ...
 
	//Invalidate the shared memory cache, forcing the ARM to re-read it from main memory
	Xil_DCacheInvalidate();
	//or alternatively Xil_DCacheInvalidate((INTPTR) shared, sizeof(shared))

	...
}