{"type":"doc","content":[{"type":"layoutSection","content":[{"type":"layoutColumn","attrs":{"width":66.66},"content":[{"type":"heading","attrs":{"level":1},"content":[{"text":"Low-level UART (Serial) Functions","type":"text"}]},{"type":"paragraph","content":[{"text":"Note: If you are connected to the FPGA via the VLAB, then the VLAB runs a serial terminal directly and you can communicate with your FPGA through the VLAB client. You can ignore this bit.","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}},{"type":"strong"}]}]},{"type":"paragraph","content":[{"text":"Xilinx SDK has a serial terminal that can be used to communicate with your design. It is in the bottom panel under the heading \"SDK Terminal\". However, this terminal is line buffered, which means that nothing is sent until you have written a line of text and clicked \"Send\". If you want to communicate using individual keypresses, you need to use a better serial terminal program. We recommend using ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"GNU screen","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}},{"type":"link","attrs":{"href":"https://www.gnu.org/software/screen/"}}]},{"text":". You can connect screen by opening a terminal and typing","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]},{"type":"paragraph","content":[{"text":" screen /dev/ttyUSB1 115200","type":"text","marks":[{"type":"subsup","attrs":{"type":"sup"}}]}]},{"type":"paragraph","content":[{"text":"Note that sometimes the FPGA appears on a different device node, so you might have to try ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"/dev/ttyUSB0","type":"text","marks":[{"type":"code"}]},{"text":" or ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"/dev/ttyUSB2","type":"text","marks":[{"type":"code"}]},{"text":".","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"type":"hardBreak"},{"type":"hardBreak"}]},{"type":"paragraph","content":[{"text":"Code examples","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}},{"type":"strong"}]}]},{"type":"paragraph","content":[{"text":"Most of the time you can use the serial/UART just by using the C standard library. Functions like ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"printf","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}},{"type":"link","attrs":{"href":"http://www.cplusplus.com/reference/cstdio/printf/"}}]},{"text":" and ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"scanf","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}},{"type":"link","attrs":{"href":"http://www.cplusplus.com/reference/cstdio/scanf/"}}]},{"text":" will work with the UART to output and input accordingly. However you might find that lower-level access to the UART hardware is useful. You can use the functions in ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"xuartps_hw.h","type":"text","marks":[{"type":"code"}]},{"text":" to do this. For example:","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"Low-level UART use","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"c++"},"content":[{"text":"#include \"xuartps_hw.h\"\n \nint main(void) {\n\tif(XUartPs_IsReceiveData(STDIN_BASEADDRESS)) { //If the user has pressed a key\n \tchar byte = XUartPs_RecvByte(STDIN_BASEADDRESS); //Read it in\n \tXUartPs_SendByte(STDOUT_BASEADDRESS, byte); //And send it out\n }\n}","type":"text"}]},{"type":"paragraph","content":[{"text":"These functions let you read and write individual bytes.","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]}]},{"type":"layoutColumn","attrs":{"width":33.33},"content":[{"type":"paragraph"},{"type":"bodiedExtension","attrs":{"layout":"default","extensionType":"com.atlassian.confluence.macro.core","extensionKey":"panel","parameters":{"macroParams":{"borderColor":{"value":"#78A270"},"bgColor":{"value":"#EFF6EF"},"titleColor":{"value":"white"},"borderWidth":{"value":"1"},"titleBGColor":{"value":"#78A270"},"borderStyle":{"value":"solid"},"title":{"value":"Contents"}},"macroMetadata":{"macroId":{"value":"8564465e-194b-4d13-a67a-f80b3bad715a"},"schemaVersion":{"value":"1"},"title":"Panel"}},"localId":"f939521d-078f-4370-9ce6-b2c72fd1c92a"},"content":[{"type":"extension","attrs":{"layout":"default","extensionType":"com.atlassian.confluence.macro.core","extensionKey":"toc","parameters":{"macroParams":{"maxLevel":{"value":"2"},"printable":{"value":"false"}},"macroMetadata":{"macroId":{"value":"bd1b20a5-af5d-40bc-89b3-a129be6747d9"},"schemaVersion":{"value":"1"},"title":"Table of Contents"}},"localId":"832d9ea5-36d7-49c3-b333-5f1b8b8caa90"}}]},{"type":"paragraph"}]}]},{"type":"layoutSection","content":[{"type":"layoutColumn","attrs":{"width":100.0},"content":[{"type":"rule"},{"type":"heading","attrs":{"level":1},"content":[{"text":"Measuring Time","type":"text"}]},{"type":"paragraph","content":[{"text":"The ARM core contains a monotonically increasing counter, which can be used to measure time in the system without controlling a full countdown timer manually (detailed below). The timer increases at half the ARM clock frequency (i.e. every two clock cycles).","type":"text"}]},{"type":"paragraph","content":[{"text":"Time can be accessed using the ","type":"text"},{"text":"XTime","type":"text","marks":[{"type":"code"}]},{"text":" functions, as follows:","type":"text"}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"XTime Example","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"c++"},"content":[{"text":"#include \"xtime_l.h\"\n \nint main() {\n XTime startTime, endTime, executionTime;\n \n\tXTime_GetTime(&startTime);\n\t// Perform execution here\n\tXTime_GetTime(&endTime);\n \n\texecutionTime = endTime - startTime;\n float timeInSecs = 1.0 * executionTime / COUNTS_PER_SECOND;\n}","type":"text"}]},{"type":"paragraph"},{"type":"rule"},{"type":"heading","attrs":{"level":1},"content":[{"text":"Countdown Timer","type":"text"}]},{"type":"paragraph","content":[{"text":"The ARM system has an internal timer which can be used to measure execution times. An example of doing this is shown below:","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"ARM internal timer","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"c++"},"content":[{"text":"#include \n#include \n\nint main() {\n\tint i;\n\tXScuTimer timer;\n\tXScuTimer_Config *timercfg;\n\n\ttimercfg = XScuTimer_LookupConfig(XPAR_SCUTIMER_DEVICE_ID);\n\tXScuTimer_CfgInitialize(&timer, timercfg, timercfg->BaseAddr);\n\n\tXScuTimer_LoadTimer(&timer, 500000000);\n\tXScuTimer_Start(&timer);\n\n\tfor(i = 0; i < 10; i++) {\n\t\tprintf(\"This is something which takes time.\\n\");\n\t}\n\n\tXScuTimer_Stop(&timer);\n\tint val = XScuTimer_GetCounterValue(&timer);\n\n\tprintf(\"Timer value: %d\\n\", val);\n\treturn 0;\n}","type":"text"}]},{"type":"paragraph","content":[{"text":"Note that the timer is a ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"countdown","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}},{"type":"strong"}]},{"text":" timer. ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"xparameters.h","type":"text","marks":[{"type":"code"}]},{"text":" includes a","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":" #define","type":"text","marks":[{"type":"code"}]},{"text":" called ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]},{"text":"XPAR_CPU_CORTEXA9_0_CPU_CLK_FREQ_HZ","type":"text","marks":[{"type":"code"}]},{"text":" which is the current clock rate. This can be used to convert clock cycles to time.","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]},{"type":"paragraph","content":[{"text":"A common use of the timer is to trigger a periodic interrupt. The code sample below shows how to set this up.","type":"text","marks":[{"type":"textColor","attrs":{"color":"#000000"}}]}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"Using the timer","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"c++"},"content":[{"text":"#include \n#include \n#include \n#include \n\nint count = 0;\n\nvoid timer_callback(XScuTimer *timer) {\n\tprintf(\"Beep %d\\n\", count++);\n\tXScuTimer_ClearInterruptStatus(timer);\n}\n\nint main() {\n\tXScuTimer timer;\n\tXScuTimer_Config *timercfg;\n\n\ttimercfg = XScuTimer_LookupConfig(XPAR_SCUTIMER_DEVICE_ID);\n\tXScuTimer_CfgInitialize(&timer, timercfg, timercfg->BaseAddr);\n\tXScuTimer_EnableAutoReload(&timer);\n\tXScuTimer_LoadTimer(&timer, XPAR_CPU_CORTEXA9_0_CPU_CLK_FREQ_HZ);\n\n\tXScuGic_DeviceInitialize(XPAR_SCUGIC_SINGLE_DEVICE_ID);\n\n\tXil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_IRQ_INT,\n\t\t\t(Xil_ExceptionHandler)XScuGic_DeviceInterruptHandler,\n\t\t\t(void *) XPAR_SCUGIC_SINGLE_DEVICE_ID);\n\n\tXScuGic_RegisterHandler(XPAR_SCUGIC_0_CPU_BASEADDR, XPAR_SCUTIMER_INTR,\n\t\t\t(Xil_ExceptionHandler) timer_callback,\n\t\t\t(void *) &timer);\n\n\tXScuGic_EnableIntr(XPAR_SCUGIC_0_DIST_BASEADDR, XPAR_SCUTIMER_INTR);\n\tXil_ExceptionEnableMask(XIL_EXCEPTION_IRQ);\n\tXScuTimer_EnableInterrupt(&timer);\n\tXScuTimer_Start(&timer);\n\n\t//Create an infinite loop because the CPU shuts down when main() returns\n\twhile(1);\n\n\treturn 0;\n}","type":"text"}]},{"type":"paragraph"},{"type":"panel","attrs":{"panelType":"error"},"content":[{"type":"heading","attrs":{"level":3},"content":[{"text":"Important","type":"text"}]},{"type":"paragraph","content":[{"text":"The ethernet framework below also makes use of this timer!","type":"text"}]}]},{"type":"paragraph"},{"type":"rule"},{"type":"heading","attrs":{"level":1},"content":[{"text":"Ethernet","type":"text"}]},{"type":"paragraph","content":[{"text":"The ARM cores can use the Zybo's Ethernet connection to send and receive messages over the network. To use the Ethernet, do the following:","type":"text"}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"In Vitis, double click your project's ","type":"text"},{"text":".prj","type":"text","marks":[{"type":"code"}]},{"text":" file and select Navigate to BSP Settings, then Modify BSP Settings.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Tick the ","type":"text"},{"text":"lwip211","type":"text","marks":[{"type":"code"}]},{"text":" (Lightweight IP) library. (Note: this may be a higher number if a more recent version has been released.)","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"In the list on the left, under standalone, click ","type":"text"},{"text":"lwip211","type":"text","marks":[{"type":"code"}]},{"text":". This shows the settings for the library.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Expand ","type":"text"},{"text":"dhcp_options","type":"text","marks":[{"type":"code"}]},{"text":" and set ","type":"text"},{"text":"lwip_dhcp","type":"text","marks":[{"type":"code"}]},{"text":" to ","type":"text"},{"text":"true","type":"text","marks":[{"type":"code"}]},{"text":".","type":"text"}]}]}]},{"type":"paragraph","content":[{"text":"This will bring in the Lightweight IP library, and set it to obtain an IP address by DHCP when your system boots.","type":"text"}]},{"type":"paragraph","content":[{"text":"Add the following two platform files to your project (or replace them if they already exist). They set up various parts of the system and initialise the hardware.","type":"text"}]},{"type":"mediaGroup","content":[{"type":"media","attrs":{"id":"8b50de36-3b6b-436f-bdd7-8805c893d7ec","collection":"contentId-35689872","type":"file"}}]},{"type":"mediaGroup","content":[{"type":"media","attrs":{"id":"7997b29e-116a-4ca6-873e-1aba6493563c","collection":"contentId-35689872","type":"file"}}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Create a ","type":"text"},{"text":"main.c","type":"text","marks":[{"type":"code"}]},{"text":" and follow the code structure as in the examples below.","type":"text"}]}]}]},{"type":"paragraph","content":[{"text":"If you are working in C++ then rename ","type":"text"},{"text":"platform.c","type":"text","marks":[{"type":"code"}]},{"text":" to ","type":"text"},{"text":"platform.cpp","type":"text","marks":[{"type":"code"}]},{"text":" and the tools should automatically use the correct compilation. You will need to wrap the LWIP includes at the top of platform.cpp ","type":"text"},{"text":"in an extern C declaration","type":"text","marks":[{"type":"link","attrs":{"href":"https://stackoverflow.com/questions/1041866/what-is-the-effect-of-extern-c-in-c"}}]},{"text":" to tell the C++ compiler to expect a C library. Like this:","type":"text"}]},{"type":"codeBlock","attrs":{"language":"c++"},"content":[{"text":"extern \"C\" {\n #include \"lwip/tcp.h\"\n #include \"lwip/init.h\n}","type":"text"}]},{"type":"paragraph"},{"type":"heading","attrs":{"level":3},"content":[{"text":"Using the Ethernet","type":"text"}]},{"type":"paragraph","content":[{"text":"The following code structure shows examples of how to use the ethernet:","type":"text","marks":[{"type":"textColor","attrs":{"color":"#333333"}}]}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"Ethernet main.c","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"c++"},"content":[{"text":"#include \n#include \"xparameters.h\"\n#include \"platform.h\"\n#include \"xil_printf.h\"\n#include \"xil_cache.h\"\n\nvoid udp_get_handler(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) {\n\t// Check that a valid protocol control block was received\n\tif (p) { \n\t\t// The message may not be zero terminated, so to ensure that we only \n\t\t// print what was sent, we can create a zero-terminated copy and print that.\n\t\tchar msg[p->len + 1];\n\t\tmemcpy(msg, p->payload, p->len);\n\t\tmsg[p->len] = '\\0';\n\t\t\n\t\tprintf(\"Message: %s\\n\", msg);\n\t\t\n\t\t// This is how we would send a reply back to the address which messaged us on port 7000\n\t\t//udp_sendto(pcb, p, addr, 7000);\n\t\t\n\t\t// Don't forget to free the packet buffer!\n\t\tpbuf_free(p);\n\t}\n}\n\nint main() {\n\tunsigned char mac_ethernet_address[] = {0x00, 0x11, 0x22, 0x33, 0x00, 0xXX}; // Put your own MAC address here!\n\tinit_platform(mac_ethernet_address, NULL, NULL);\n\t\n\tstruct udp_pcb *recv_pcb = udp_new();\n\tif (!recv_pcb) {\n\t\tprintf(\"Error creating PCB\\n\");\n\t}\n\t\n\t// Listen on port 7001\n\tudp_bind(recv_pcb, IP_ADDR_ANY, 7001);\n\t// Set up the receive handler\n\tudp_recv(recv_pcb, udp_get_handler, NULL);\n\t\n\t// Send an initial message\n\t// Create a protocol control block (PCB)\n\tstruct udp_pcb *send_pcb = udp_new();\n\t// Create a packet buffer and set the payload as the message\n\tstruct pbuf * reply = pbuf_alloc(PBUF_TRANSPORT, strlen(message), PBUF_REF);\n\treply->payload = message;\n\treply->len = strlen(message);\n\t// Send the message\n\tip_addr_t ip;\n\tIP4_ADDR(&ip, 192, 168, 9, 1);\n\tudp_sendto(send_pcb, reply, &ip, 8000);\n\t\n\t// Don't forget to free the packet buffer!\n\tpbuf_free(reply);\n\t\n\t// Remove the send PCB because we don't re-use it in this example\n\tudp_remove(send_pcb);\n\t\n\t// Now enter the handling loop\n\twhile (1) {\n\t\thandle_ethernet();\n\t}\n\treturn 0;\n}","type":"text"}]},{"type":"paragraph","content":[{"text":"Important things to note:","type":"text"}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"The above code is just to show sample usage, ","type":"text"},{"text":"and will not compile as it is.","type":"text","marks":[{"type":"strong"}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"You must use a unique MAC address.","type":"text","marks":[{"type":"strong"}]},{"text":" In EMBS these are listed on the ","type":"text"},{"text":"EMBS Student Network","type":"text","marks":[{"type":"link","attrs":{"href":"https://uoy.atlassian.net/wiki/spaces/RTS/pages/35688062"}}]},{"text":" page.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Sending and receiving requires a packet buffer (","type":"text"},{"text":"pbuf","type":"text","marks":[{"type":"code"}]},{"text":"). You must remember to free these after using them.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Sending and receiving also requires Protocol Control Blocks (PCBs). While you can remove these when you've finished using them, we recommend re-using them if you're going to send or receive more than once.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"After setting up any handlers you must call ","type":"text"},{"text":"handle_ethernet()","type":"text","marks":[{"type":"code"}]},{"text":".","type":"text"}]}]}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"If you don't have DHCP","type":"text"}]},{"type":"paragraph","content":[{"text":"The default ethernet code uses DHCP to automatically obtain an IP address from the network, based on your MAC address. If DHCP requests aren't working, it often means you're not connected to the network correctly, or you have a problem with your code. There could also be network issues, so ask a demonstrator if unsure.","type":"text"}]},{"type":"paragraph","content":[{"text":"If you're sure that you shouldn't be using DHCP (e.g. if you're not using the EMBS network), you can use a manual IP address as follows:","type":"text"}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Set up the application and BSP as above.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Right click your BSP and click Board Support Package Settings. In the left-hand column, under ","type":"text"},{"text":"standalone","type":"text","marks":[{"type":"code"}]},{"text":", click ","type":"text"},{"text":"lwip202","type":"text","marks":[{"type":"code"}]},{"text":".","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Expand ","type":"text"},{"text":"dhcp_options","type":"text","marks":[{"type":"code"}]},{"text":" and set ","type":"text"},{"text":"dhcp_does_arp_check","type":"text","marks":[{"type":"code"}]},{"text":" and ","type":"text"},{"text":"lwip_dhcp","type":"text","marks":[{"type":"code"}]},{"text":" both to false.","type":"text"}]}]}]},{"type":"paragraph","content":[{"text":"Now you must provide an IP address and subnet mask manually, as below:","type":"text"}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"Manually specifying IP address","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"c++"},"content":[{"text":"int main() {\n\tip_addr_t ipaddr, netmask;\n\tIP4_ADDR(&ipaddr, 192, 168, 0, 30);\n\tIP4_ADDR(&netmask, 255, 255, 255, 0);\n\tunsigned char mac_ethernet_address[] = {0x00, 0x0a, 0x35, 0x00, 0x07, 0x02};\n\tinit_platform(mac_ethernet_address, &ipaddr, &netmask);\n\t...\n}","type":"text"}]},{"type":"paragraph"},{"type":"rule"},{"type":"heading","attrs":{"level":1},"content":[{"text":"Sharing Memory Between HLS and the ARM","type":"text"}]},{"type":"paragraph","content":[{"text":"To share a large amount of data between the ARM cores and an HLS component you will use main system memory. The Zybo Z7 has 1GB of main DDR memory which can be accessed from an HLS component by using an AXI Master interface on the HLS core.","type":"text"}]},{"type":"paragraph","content":[{"text":"Look at this diagram. It helps to understand how the system is laid out.","type":"text"}]},{"type":"mediaSingle","attrs":{"layout":"align-start","width":66.0},"content":[{"type":"media","attrs":{"width":456,"id":"660cf144-69a2-4b16-ad10-33c25c825b28","collection":"contentId-35689872","type":"file","height":248}}]},{"type":"paragraph","content":[{"text":"The ARM cores read and write data from main memory. Your HLS core is controlled by the ARM over its slave interface, but it can also access main memory via its master interface. ","type":"text"},{"text":"For this reason, you should see why it doesn't make sense to ask \"how do I pass data from the ARM core to HLS?\". The data is always in memory, instead the ARM core simply needs to tell the FPGA where to look for it.","type":"text","marks":[{"type":"strong"}]}]},{"type":"paragraph","content":[{"text":"We can see therefore that the HLS core and the ARM cores are reading and writing from the same memory. Therefore we will declare a segment of that memory that we can use for sharing. The easiest way to do this is to declare a global array, then pass the address of the shared memory into the HLS component using ","type":"text"},{"text":"XToplevel_Set_ram","type":"text","marks":[{"type":"code"}]},{"text":":","type":"text"}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"Declare a segment of shared memory","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"c++"},"content":[{"text":"int sharedmemory[1000]; //Reserve 1000 integers (4000 bytes)\n \nint main(void) {\n\t//Pass the address to the hardware.\n\tXToplevel_Set_ram(&hls, sharedmemory);\n \n\t//Rest of the application...\n}","type":"text"}]},{"type":"paragraph","content":[{"text":"In HLS we can read and write from RAM address 0 and it will be offset by the value we passed in with ","type":"text"},{"text":"XToplevel_Set_ram","type":"text","marks":[{"type":"code"}]},{"text":" to access the shared memory:","type":"text"}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"Using the address in HLS","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"c++"},"content":[{"text":"uint32 toplevel(uint32 *ram, uint32 arg1) {\n\t#pragma HLS INTERFACE m_axi port=ram offset=slave bundle=MAXI\n\t#pragma HLS INTERFACE s_axilite port=arg1 bundle=AXILiteS register\n\t#pragma HLS INTERFACE s_axilite port=return bundle=AXILiteS register\n \n\tram[0] = 1234;\n\tram[1] = 5678;\n \n\t//Or to bulk read/write memory we can use memcpy. eg. to write an array to RAM...\n\tint output[1000];\n\tmemcpy(ram, output, 4000);\n}","type":"text"}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"In the example above we declared 4000 bytes to use as shared memory between HLS and the ARM cores. This is not only \"input\" data, it is ","type":"text"},{"text":"shared","type":"text","marks":[{"type":"em"}]},{"text":" data. If your algorithm needs to read in some input data and produces a chunk of output data, you can arrange it all in the array accordingly. For example, imagine a problem which takes in 400 bytes and produces 400 bytes:","type":"text"}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"Returning lots of data","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"c++"},"content":[{"text":"int sharedmemory[200]; //400 bytes of input, 400 bytes of output == 800 bytes, or 200 ints.\n\n//Prepare input data\nfor(int i = 0; i < 100; i++) sharedmemory[i] = get_input_data(i);\n\n//Run the IP core\nXToplevel_Set_ram(&hls, sharedmemory);\nXToplevel_Start(&hls);\nwhile(!XToplevel_IsDone(&hls));\n\n//sharedmemory[100] to sharedmemory[199] contains the output data\n\n//-------------------------\n//Meanwhile in HLS...\n\nuint32 toplevel(uint32 *ram) {\n\t#pragma HLS INTERFACE m_axi port=ram offset=slave bundle=MAXI\n\t#pragma HLS INTERFACE s_axilite port=return bundle=AXILiteS register\n\n\tint mydata[100];\n \n\t//Read input data from ram[0-99] into our local cache mydata\n\tmemcpy(mydata, ram, 400);\n\n\t//Do whatever we need to do\n\tprocessData(mydata);\n\n\t//Write mydata out to the return part of memory\n\tmemcpy(ram+100, mydata, 400);\n}\n\n","type":"text"}]},{"type":"paragraph"},{"type":"paragraph","content":[{"text":"Bulk reads and writes with ","type":"text"},{"text":"memcpy","type":"text","marks":[{"type":"code"}]},{"text":" (include ","type":"text"},{"text":"string.h","type":"text","marks":[{"type":"code"}]},{"text":") are faster than reading individual words. For example:","type":"text"}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"Use of memcpy","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"c++"},"content":[{"text":"#include \n \nuint32 toplevel(uint32 *ram) {\n\t#pragma HLS INTERFACE m_axi port=ram offset=slave bundle=MAXI\n\t#pragma HLS INTERFACE s_axilite port=return bundle=AXILiteS register\n \n\tint datain[50];\n \n\t//Using individual reads\n\tfor(int i = 0; i < 50; i++) {\n\t\tdatain[i] = ram[i];\n\t}\n \n\t//Using memcpy\n\tmemcpy(datain, ram, 50 * sizeof(int));\n}","type":"text"}]},{"type":"paragraph","content":[{"text":"Both the loop and the call to ","type":"text"},{"text":"memcpy","type":"text","marks":[{"type":"code"}]},{"text":" do the same thing, but ","type":"text"},{"text":"memcpy","type":"text","marks":[{"type":"code"}]},{"text":" is much faster because HLS will use what is called a ","type":"text"},{"text":"burst transfer","type":"text","marks":[{"type":"em"}]},{"text":" to copy in data at a faster rate. You can also ","type":"text"},{"text":"memcpy","type":"text","marks":[{"type":"code"}]},{"text":" data out to RAM.","type":"text"}]},{"type":"paragraph","content":[{"text":"Remember that the system contains caches! If you simply write data and do nothing else the ARM will write and read from its caches, which are not visible to the HLS component. Also any memory changed by HLS will not invalidate the ARM's cache lines so you may not see the updates. You must flush the caches when you want to force the ARM to write to or read from system memory. For example:","type":"text"}]},{"type":"heading","attrs":{"level":5},"content":[{"text":"Caching","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","attrs":{"language":"c++"},"content":[{"text":"#include \n \nint shared[1000];\n\nint main() {\n\t//Write to shared\n\t...\n \n\n\t//Force the writes to main memory\n\tXil_DCacheFlush();\n\t//or alternatively Xil_DCacheFlushRange((INTPTR) shared, sizeof(shared));\n \n\t//Start the HLS component\n\tXToplevel_Start(&hls);\n ...\n \n\t//Invalidate the shared memory cache, forcing the ARM to re-read it from main memory\n\tXil_DCacheInvalidate();\n\t//or alternatively Xil_DCacheInvalidateRange((INTPTR) shared, sizeof(shared))\n\n\t...\n}","type":"text"}]},{"type":"paragraph","content":[{"text":"This code uses ","type":"text"},{"text":"Xil_DCacheFlush()","type":"text","marks":[{"type":"code"}]},{"text":" and ","type":"text"},{"text":"Xil_DCacheInvalidate()","type":"text","marks":[{"type":"code"}]},{"text":" to flush changes from the cache to main memory and re-read from main memory into cache. ","type":"text"},{"text":"Xil_DCacheFlushRange()","type":"text","marks":[{"type":"code"}]},{"text":" and ","type":"text"},{"text":"Xil_DCacheInvalidateRange()","type":"text","marks":[{"type":"code"}]},{"text":" can also be used to specify regions of memory that have changed.","type":"text"}]},{"type":"paragraph","content":[{"text":"If you are having issues which you suspect are cache-related you can completely disable caches by calling ","type":"text"},{"text":"Xil_DCacheDisable()","type":"text","marks":[{"type":"code"}]},{"text":", but this will make your code a lot slower.","type":"text"}]},{"type":"paragraph"},{"type":"rule"},{"type":"heading","attrs":{"level":1},"content":[{"text":"Using C Maths Functions","type":"text"}]},{"type":"paragraph","content":[{"text":"Functions such as ","type":"text"},{"text":"sin","type":"text","marks":[{"type":"code"}]},{"text":" and ","type":"text"},{"text":"floor","type":"text","marks":[{"type":"code"}]},{"text":" are defined in the standard C header ","type":"text"},{"text":"math.h","type":"text","marks":[{"type":"code"}]},{"text":". If you use this you may find that the compiler does not include the maths library by default, resulting in errors like:","type":"text"}]},{"type":"paragraph","content":[{"text":"undefined reference to `sin'","type":"text","marks":[{"type":"code"}]}]},{"type":"paragraph","content":[{"text":"To fix this:","type":"text"}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"In SDK, right click your application project and select ","type":"text"},{"text":"Properties","type":"text","marks":[{"type":"code"}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Go to ","type":"text"},{"text":"C/C++ Build | Settings","type":"text","marks":[{"type":"code"}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"In the ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#242729"}}]},{"text":"Tool Settings","type":"text","marks":[{"type":"code"}]},{"text":" tab, under ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#242729"}}]},{"text":"ARM v7 gcc linker","type":"text","marks":[{"type":"code"}]},{"text":" click ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#242729"}}]},{"text":"Libraries","type":"text","marks":[{"type":"code"}]}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Click the Add button and enter ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#242729"}}]},{"text":"m","type":"text","marks":[{"type":"code"}]},{"type":"hardBreak"},{"text":" ","type":"text","marks":[{"type":"textColor","attrs":{"color":"#242729"}}]}]}]}]},{"type":"mediaSingle","attrs":{"layout":"align-start","width":65.0},"content":[{"type":"media","attrs":{"width":466,"id":"46b89d00-58f1-434a-b5f9-fc9c8aa23850","collection":"contentId-35689872","type":"file","height":258}}]}]}]}],"version":1}

Browser not supported