{"id":9410,"date":"2025-04-18T09:11:14","date_gmt":"2025-04-18T09:11:14","guid":{"rendered":"https:\/\/liquidinstruments.com\/?p=9410"},"modified":"2025-06-11T22:34:54","modified_gmt":"2025-06-11T22:34:54","slug":"cloud-compile-with-mathworks-hdl-coder-pt-2","status":"publish","type":"post","link":"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/","title":{"rendered":"Moku Cloud Compile with MathWorks HDL Coder \u2013 Part 2: Simulink","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

This is Part 2 of the \u201cMoku Cloud Compile with MathWorks HDL Coder\u201d tutorial. Part 1 can be found here<\/a>. Now, we will use MathWorks\u2019 Simulink to build and deploy a two-channel Schmitt trigger on Moku:Pro. The general workflow between the MATLAB script approach and Simulink model approach is similar, but Simulink provides additional first-party DSP and test blocks that are ready to use. The block diagram-based design method provides a more intuitive way to construct a DSP workflow, especially for more complicated systems. In this tutorial, we will construct the first channel via a hybrid MATLAB-Simulink design and the second channel with the Simulink library.<\/p>\n

\n

Overview<\/h2>\n

Liquid Instruments\u2019 Moku Cloud Compile (MCC) tool enables users to design custom instruments for implementation on Moku platforms. Compared to CPU and application-specific integrated circuit (ASIC) based DSP approaches, FPGAs provide ASIC-level input-to-output latency while being software-defined and reprogrammable like a CPU. FPGA programming is typically done with hardware description language (HDL). The learning curve for HDL coding can be steep compared to software programming languages, but there are a few tools available to convert scripts in other programming languages to HDL. We covered how to use MathWorks HDL coder to convert a MATLAB script into HDL code for implementation on a Moku:Pro in Part I of the tutorial, in this Part II we will demonstrate how to generate HDL code from a Simulink model.<\/p>\n

Simulink is a graphical-based modeling tool developed by MathWorks. The block diagram-based design philosophy streamlines the process of translating a hand-drawn digital signal processing (DSP) system into a computer-based model. The virtual test and measurement instruments, such as waveform generators and oscilloscopes, provide a more intuitive way to construct the testbench and validate the DSP model. In addition, users have the option to use Simulink to build a fixed-point system from the ground up. Some of the logic operations are easier to implement with MATLAB functions, in this case users can add MATLAB function blocks into their design. For more complicated systems, utilizing both tools could significantly streamline the design process.<\/p>\n

In this tutorial, we will construct a two-channel Schmitt trigger. The basics and concept design of the Schmitt Trigger can be found Part I of the tutorial. For the first channel, we will use the exact same MATLAB function from Part I of the tutorial to construct the DSP. For the second channel, we will use a Simulink built-in DSP block to achieve the same function.<\/p>\n

\"Figure
\nFigure 1: Recommended workflow for Moku Cloud Compile + HDL Coder DSP Design.<\/em><\/p>\n

Requirements<\/h4>\n

Before we get started with building and implementing the Schmitt trigger, please ensure your system satisfies the following requirements. For generating VHDL code from a Simulink model you will need to have MATLAB with Simulink, HDL Coder, and Fixed-Point Converter. Note: Mac users will also need to have XCode installed for MATLAB to generate the VHDL code. For compiling the VHDL code you will need to have access to Moku Cloud Compile. For implementing the compiled instrument bitstream, you will need to have a Moku:Pro running firmware version 601 or above, the Moku: app, and access to Multi-Instrument Mode<\/a> on your Moku:Pro.<\/p>\n

Design and construct the DSP<\/h2>\n

Adjust the template<\/h4>\n

The first step in creating our model is to adjust the Simulink template to fit our DSP design. As our design is a two-channel system, we will only need the InputA, InputB, OutputA, and OutputB ports.<\/p>\n

\"Figure
\nFigure 2: Remove the redundant channels.<\/em><\/p>\n

Floating-point DSP design<\/h4>\n

In this section we will construct the two Schmitt triggers, with the first channel using a MATLAB function block and the second channel using a Simulink trigger block.<\/p>\n

Simulink building blocks can be found in the \u201cLibrary Browser\u201d under the simulation tab. The search function is the best way to find the desired element. Please note that not all Simulink blocks support HDL code generation. We recommend only using blocks under the \u201cHDL Coder\u201d or \u201cHDL Support\u201d catalog for everything within the DSP subsystem.<\/p>\n

\"Figure
\nFigure 3: Simulink building blocks can be found via the Library Browser.<\/em><\/p>\n

For the first channel we will place a MATLAB function block in the model. As the MATLAB function is a floating-point model and the Simulink template has pre-defined the data type for all the ports, the data type will not match. We address this issue by placing two \u201cconvert\u201d blocks before and after the MATLAB function block. Users can design the model with a fixed-point algorithm, but we find it is easier to start with floating-point when implementing a MATLAB function block in the model. Please note the first convert block may need to be removed before the HDL conversion step.<\/p>\n

To add the Schmitt trigger function to the MATLAB function block, double-click the block. We will use the same MATLAB function as Part I of the tutorial, except for the function name (so we are not using the same name for the MATLAB function and Simulink subsystem).<\/p>\n

\"Figure
\nFigure 4: Block diagram design of the MATLAB function-based Schmitt trigger.<\/em><\/p>\n

 <\/p>\n

\n
function OutputA = Schmitt_Trigger(InputA)<\/span>\r\n%#codegen<\/span>\r\npersistent out0;<\/span> %Retains variable value between function calls.<\/span>\r\nif isempty(out0)<\/span> %Initialize the value for the first call.<\/span>\r\n     out0 = 0;<\/span>\r\nend\r\n\r\nupperThreshold = floor(2^15\/10);<\/span> %Set the upper threshold to 1\/10 of the full positive range.<\/span>\r\nlowerThreshold = -floor(2^15\/10);<\/span> %Set the lower threshold to 1\/10 of the full negative range.<\/span>\r\n\r\nif InputA >upperThrehold<\/span> %Logic to perform the Schmitt trigger function.<\/span>\r\n     out0 = 2^15-1;<\/span> %Map to the highest positive number.<\/span>\r\nelseif InputA <lowerThreshold<\/span>\r\n     out0 = 0;<\/span>\r\nend\r\n\r\nOutputA = out0;<\/span> %Assign variable out0 to OutputA.<\/span><\/span><\/pre>\n<\/blockquote>\n
 <\/p>\n
For the second channel, we will use Simulink\u2019s \u201cRelay\u201d block to perform the Schmitt trigger logic. We placed the relay block between InputB and OutputB, then double-clicked the \u201cRelay\u201d block to change the switch on and off thresholds to floor(2^15\/10), and – floor(2^15\/10), respectively. In the \u201cSignal Attributes\u201d tab, set the signal output to fixdt(1, 16,0)<\/em> to match the output.<\/p>\n
\"Figure
\nFigure 5: The “Relay” block was set to perform the same Schmitt trigger logic as the first channel.<\/em><\/p>\n
Construct the testbench<\/h4>\n
Simulink has a built-in signal generator, oscilloscope, and other common test and measurement equipment blocks. This allows us to design the testbench in a more intuitive way. Please note the building blocks outside of the DSP system do not need to be supported by HDL Coder, as they will be used for simulation only.<\/p>\n
To construct the testbench, we used a \u201cSignal Generator\u201d block to produce the same signal we used for the testbench in Part I. We rescaled and converted the signal from the generator to match the 16-bit signed input for our system. Before feeding the signal into the Inputs, an additional \u201cConvert\u201d block was added to convert the floating-point numbers to fixed-point. Then, we fed the generator signal, OuputA, and OutputB into the oscilloscope to observe the system response.<\/p>\n
\"Figure
\nFigure 6: Block diagram of the Simulink-based testbench.<\/em><\/p>\n
Once the system is constructed, we run the simulation and verify the output. We observed the output signal was as expected.<\/p>\n
\"Figure
\nFigure 7: The output of the DSP subsystem on the Oscilloscope.<\/em><\/p>\n
Fixed-point conversion<\/h4>\n
Before generating the VHDL code for our DSP subsystem, we will need to convert the floating-point MATLAB function block to a fixed-point function block. We achieve this using MathWorks\u2019 Fixed-Point Tool in the \u201cApps\u201d tab, with \u201cIterative Fixed-Point Conversion\u201d method. Please note that if we build the Simulink model with fixed-point DSP from the beginning, we do not have to run the fixed-point conversion.<\/p>\n
\"Figure
\nFigure 8: Iterative Fixed-Point Conversion can be initiated via the Simulink Apps tab.<\/em><\/p>\n
Next, we selected the MATLAB function as the target and initiated the conversion process by clicking the \u201cCollect Ranges\u201d button. Simulink uses the testbech data points as the reference to convert the model.<\/p>\n
\"Figure
\nFigure 9: The MATLAB function was selected as the “System Under Design.”<\/em><\/p>\n
Then, we can use the \u201cPropose Data Types\u201d button to let Simulink decide the best fixed-point precision. The histograms in the bottom displays the range of each signal. We can manually override any signal precision if needed. Once the precisions are decided, we can use the \u201cApply Data Types\u201d button to proceed the conversion.<\/p>\n
\"Figure
\nFigure 10: (1) Propose the signal precision based on the testbench data; (2) Observe the signal range with the histograms; (3) Proceed to convert the model to fixed-point design. (4) Delete the first “convert” block.<\/em><\/p>\n
After the fixed-point conversion, the first “Convert” block needs to be removed; as the new “MATLAB Function” block takes in fixed-point numbers instead of floating\/double.<\/p>\n
Fixed-point model verification<\/h4>\n
After the models have been converted, it is important to run another round of simulation to make sure the behaviors and precision loss are as expected.<\/p>\n
VHDL code generation<\/h4>\n
HDL code can be generated by clicking the “Generate HDL Code” button under the HDL Code tab. HDL Coder generation settings are already preconfigured in the Simulink template, therefore we do not need to adjust settings here.<\/p>\n
\"Figure
\nFigure 11: “Generate HDL Code” button is located under the HDL Code app.<\/em><\/p>\n
VHDL simulation with a third-party tool (Optional)<\/h4>\n
VHDL testbench file can be generated by clicking the “Generate Testbench” button under the HDL Code app. The verification step is identical to the MATLAB example.<\/p>\n
\"
\nFigure 12: “Generate Testbench” button is located under the HDL Code app.<\/em><\/p>\n
DSP Compile and Deployment<\/h2>\n
Moku Cloud Compile has a standard wrapper built-in to allow the custom instrument to interact with the other parts of the Moku:Pro. The standard wrapper uses all four input channels and output channels for the instrument; this does not match our Schmitt trigger example, which has two inputs and two outputs. Therefore, we will need to create a custom wrapper for the instrument from the provided template.<\/p>\n
Please note even with the \u201cMinimize clock enables\u201d option selected, sometimes HDL Coder still generates VHDL code with clock_enable<\/em> and ce_out<\/em> ports (like in this tutorial). We will connect the clock_enable<\/em> with a constant high signal and leave the ce_out ports open if these ports are created during the VHDL conversion process.<\/p>\n
\n
ARCHITECTURE HDLCoderWrapper<\/span> OF CustomWrapper<\/span> IS\r\n-- SIGNAL Declarations<\/span>\r\nSIGNAL ConstantHigh:std_logic.        :='1';<\/span>\r\n--Component Declarations<\/span>\r\nCOMPONENT DSP<\/span>\r\nPORT(Clk                              :<\/span> IN<\/span> std_logic;<\/span>\r\n     Reset                            :<\/span> IN<\/span> std_logic;<\/span>\r\n     clk_enable                       :<\/span> IN<\/span> std_logic;<\/span>\r\n     InputA                           :<\/span> IN<\/span> signed(15 DOWNTO 0); -- sfix16_En16<\/span>\r\n     InputB<\/span>                           :<\/span> IN<\/span> signed(15 DOWNTO 0); -- sfix16_En16<\/span>\r\n     ce_out_0                         :<\/span> OUT<\/span> std_logic;<\/span>\r\n     ce_out_1                         :<\/span> OUT<\/span> std_logic;<\/span>\r\n     OutputA                          :<\/span> OUT<\/span> signed(15 DOWNTO 0); -- sfix16_En14<\/span>\r\n     OutputB                          :<\/span> OUT<\/span> signed(15 DOWNTO 0); -- sfix16_En14<\/span>\r\n     );<\/span>\r\nEND COMPONENT;<\/span>\r\n\r\nBEGIN\r\n     u_DSP:DSP<\/span>\r\n          PORT MAP(Clk => Clk,<\/span>\r\n               Reset => Reset,<\/span>\r\n               clk_enable => ConstantHigh,<\/span>\r\n               InputA => InputA,<\/span>\r\n               InputB => InputB,<\/span>\r\n               ce_out_0 => open<\/span>,<\/span>\r\n               ce_out_1 => open<\/span>,<\/span>\r\n               OutputA => OutputA,<\/span>\r\n               OutputB => OutputB<\/span>\r\n          );<\/span>\r\nEND<\/span> HDLCoderWrapper;<\/span><\/span><\/pre>\n<\/blockquote>\n
Compiling and deploying the instrument<\/h4>\n
Detailed instructions on how to use Moku Cloud Compile to build instrument bitstream and deploy the instrument can be found in our Moku Cloud Compile Getting Started Guide<\/a>.<\/p>\n
To compile the Schmitt trigger, create a new project on Liquid Instruments’ Moku Cloud Compile. In this project, create a file for the DSP_fixpt.vhd, which is the VHDL code for the Schmitt trigger; also create a wrapper file for the custom wrapper from the previous sections. Select a target device as a Moku:Pro with 4 slots and build the project. Once the bitstream is built, you will be able to deploy the Schmitt trigger on your Moku:Pro using the web interface and the Moku: app.<\/p>\n
To demonstrate the Schmitt trigger is functioning as per our conceptual design, we implemented the instrument on a Moku:Pro using the Moku: App and Multi-Instrument Mode. In slot 1, we placed in an Arbitrary Waveform Generator to generate the same signal we have used in the testbench as the input signal to the Schmitt trigger. In slot 2, we placed in our Schmitt trigger. In Slot 3, we placed in an Oscilloscope to compare the output signals from the Schmitt trigger and the Arbitrary Waveform Generator.<\/p>\n
We first verify the Schmitt trigger in Channel A designed with the MATLAB function block. We can confirm the output from the Schmitt trigger is switched to high when the input signal is above 110 mV and waited until the signal is dropped below -110 mV to switch to zero.<\/p>\n
\"Figure
\nFigure 13: (a) Multi-instrument system configuration for testing the MATLAB function bloc Schmitt trigger. (b) Oscilloscope measurement verifying the Schmitt trigger is functioning as designed.<\/em><\/p>\n
We also verified the Schmitt trigger in Channel B, which was designed using the Simulink trigger block, and observed the same behavior.<\/p>\n
\"Figure
\nFigure 14: (a) Multi-instrument system configuration for testing the Simulink trigger block Schmitt trigger. (b) Oscilloscope measurement verifying the Schmitt trigger is functioning as designed.<\/em><\/p>\n
Finally we compared the two output channels together and can verify that they switch to high and low at the same point.<\/p>\n
\"Figure
\nFigure 15: The Schmitt trigger designed using the MATLAB function block and the trigger block have the same behaviors.<\/em><\/p>\n
Conclusion<\/h2>\n
In this second part of the tutorial, we covered how to utilize MathWorks\u2019 Simulink and HDL Coder to build, validate, and deploy a DSP model on Moku:Pro. Compared to MATLAB only approach, Simulink gives you the option to design the DSP via its DSP library and build the model with the fixed-point model from the ground up. It is recommended for building complicated DSP systems.<\/p>\n
Code availability<\/h2>\n
The source code for this project can be downloaded here<\/a>.<\/p>\n
\n
<\/h2>\n
Have questions or want a printable version?<\/h2>\n
Please contact us at support@liquidinstruments.com<\/a><\/p>\n
 <\/p>\n
 <\/p>\n","protected":false,"gt_translate_keys":[{"key":"rendered","format":"html"}]},"excerpt":{"rendered":"
This is Part 2 of the \u201cMoku Cloud Compile with MathWorks HDL Coder\u201d tutorial. Part 1 can be found here. Now, we will use MathWorks\u2019 Simulink to build and deploy a two-channel Schmitt trigger on Moku:Pro. The general workflow between the MATLAB script approach and Simulink model approach is similar, but Simulink provides additional first-party […]<\/p>\n","protected":false,"gt_translate_keys":[{"key":"rendered","format":"html"}]},"author":14,"featured_media":23745,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"content-type":"","footnotes":""},"categories":[5],"tags":[],"class_list":["post-9410","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-application-notes","site-category-matlab","site-category-moku-cloud-compile","site-category-mokupro"],"acf":[],"yoast_head":"\nMoku Cloud Compile with MathWorks HDL Coder \u2013 Part 2: Simulink - Liquid Instruments<\/title>\n<meta name=\"description\" content=\"This is Part 2 of the \u201cMoku Cloud Compile with MathWorks HDL Coder\u201d tutorial. Part 1 can be found here. Now, we will use MathWorks\u2019 Simulink to build and\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Moku Cloud Compile with MathWorks HDL Coder \u2013 Part 2: Simulink\" \/>\n<meta property=\"og:description\" content=\"This is Part 2 of the \u201cMoku Cloud Compile with MathWorks HDL Coder\u201d tutorial. Part 1 can be found here. Now, we will use MathWorks\u2019 Simulink to build and\" \/>\n<meta property=\"og:url\" content=\"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/\" \/>\n<meta property=\"og:site_name\" content=\"Liquid Instruments\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/LiquidInstruments\/\" \/>\n<meta property=\"article:published_time\" content=\"2025-04-18T09:11:14+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-06-11T22:34:54+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/liquidinstruments.com\/wp-content\/uploads\/2021\/10\/Figure1-2.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1279\" \/>\n\t<meta property=\"og:image:height\" content=\"705\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"joel\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@liquidinstrmnts\" \/>\n<meta name=\"twitter:site\" content=\"@liquidinstrmnts\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"joel\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"13 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/\"},\"author\":{\"name\":\"joel\",\"@id\":\"https:\/\/liquidinstruments.com\/#\/schema\/person\/603af464a65f123df56503f020b73dba\"},\"headline\":\"Moku Cloud Compile with MathWorks HDL Coder \u2013 Part 2: Simulink\",\"datePublished\":\"2025-04-18T09:11:14+00:00\",\"dateModified\":\"2025-06-11T22:34:54+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/\"},\"wordCount\":2034,\"publisher\":{\"@id\":\"https:\/\/liquidinstruments.com\/#organization\"},\"image\":{\"@id\":\"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/liquidinstruments.com\/wp-content\/uploads\/2021\/10\/Figure1-2.png\",\"articleSection\":[\"Application notes\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/\",\"url\":\"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/\",\"name\":\"Moku Cloud Compile with MathWorks HDL Coder \u2013 Part 2: Simulink - Liquid Instruments\",\"isPartOf\":{\"@id\":\"https:\/\/liquidinstruments.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/liquidinstruments.com\/wp-content\/uploads\/2021\/10\/Figure1-2.png\",\"datePublished\":\"2025-04-18T09:11:14+00:00\",\"dateModified\":\"2025-06-11T22:34:54+00:00\",\"description\":\"This is Part 2 of the \u201cMoku Cloud Compile with MathWorks HDL Coder\u201d tutorial. Part 1 can be found here. Now, we will use MathWorks\u2019 Simulink to build and\",\"breadcrumb\":{\"@id\":\"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/#primaryimage\",\"url\":\"https:\/\/liquidinstruments.com\/wp-content\/uploads\/2021\/10\/Figure1-2.png\",\"contentUrl\":\"https:\/\/liquidinstruments.com\/wp-content\/uploads\/2021\/10\/Figure1-2.png\",\"width\":1279,\"height\":705,\"caption\":\"Figure 1: Recommended workflow for Moku Cloud Compile + HDL Coder DSP Design.\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/liquidinstruments.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Moku Cloud Compile with MathWorks HDL Coder \u2013 Part 2: Simulink\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/liquidinstruments.com\/#website\",\"url\":\"https:\/\/liquidinstruments.com\/\",\"name\":\"Liquid Instruments\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/liquidinstruments.com\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/liquidinstruments.com\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/liquidinstruments.com\/#organization\",\"name\":\"Liquid Instruments\",\"url\":\"https:\/\/liquidinstruments.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/liquidinstruments.com\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/i0.wp.com\/liquidinstruments.com\/wp-content\/uploads\/2020\/10\/BrandMark-Preferred-RGB-Color.png?fit=1000%2C924&ssl=1\",\"contentUrl\":\"https:\/\/i0.wp.com\/liquidinstruments.com\/wp-content\/uploads\/2020\/10\/BrandMark-Preferred-RGB-Color.png?fit=1000%2C924&ssl=1\",\"width\":1000,\"height\":924,\"caption\":\"Liquid Instruments\"},\"image\":{\"@id\":\"https:\/\/liquidinstruments.com\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/www.facebook.com\/LiquidInstruments\/\",\"https:\/\/x.com\/liquidinstrmnts\",\"https:\/\/www.instagram.com\/liquidinstruments\/\",\"https:\/\/www.linkedin.com\/company\/liquidinstruments\/\",\"https:\/\/www.youtube.com\/c\/LiquidInstruments\",\"https:\/\/vimeo.com\/liquidinstruments\"],\"hasMerchantReturnPolicy\":{\"@type\":\"MerchantReturnPolicy\",\"merchantReturnLink\":\"https:\/\/liquidinstruments.com\/support\/warranty-repairs-and-service\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\/\/liquidinstruments.com\/#\/schema\/person\/603af464a65f123df56503f020b73dba\",\"name\":\"joel\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/liquidinstruments.com\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/61d26ea66bf9fb0a2379e1e6e8febb312981e656713bff920c55016dfe82495d?s=96&d=wavatar&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/61d26ea66bf9fb0a2379e1e6e8febb312981e656713bff920c55016dfe82495d?s=96&d=wavatar&r=g\",\"caption\":\"joel\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Moku Cloud Compile with MathWorks HDL Coder \u2013 Part 2: Simulink - Liquid Instruments","description":"This is Part 2 of the \u201cMoku Cloud Compile with MathWorks HDL Coder\u201d tutorial. Part 1 can be found here. Now, we will use MathWorks\u2019 Simulink to build and","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/","og_locale":"en_US","og_type":"article","og_title":"Moku Cloud Compile with MathWorks HDL Coder \u2013 Part 2: Simulink","og_description":"This is Part 2 of the \u201cMoku Cloud Compile with MathWorks HDL Coder\u201d tutorial. Part 1 can be found here. Now, we will use MathWorks\u2019 Simulink to build and","og_url":"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/","og_site_name":"Liquid Instruments","article_publisher":"https:\/\/www.facebook.com\/LiquidInstruments\/","article_published_time":"2025-04-18T09:11:14+00:00","article_modified_time":"2025-06-11T22:34:54+00:00","og_image":[{"width":1279,"height":705,"url":"https:\/\/liquidinstruments.com\/wp-content\/uploads\/2021\/10\/Figure1-2.png","type":"image\/png"}],"author":"joel","twitter_card":"summary_large_image","twitter_creator":"@liquidinstrmnts","twitter_site":"@liquidinstrmnts","twitter_misc":{"Written by":"joel","Est. reading time":"13 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/#article","isPartOf":{"@id":"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/"},"author":{"name":"joel","@id":"https:\/\/liquidinstruments.com\/#\/schema\/person\/603af464a65f123df56503f020b73dba"},"headline":"Moku Cloud Compile with MathWorks HDL Coder \u2013 Part 2: Simulink","datePublished":"2025-04-18T09:11:14+00:00","dateModified":"2025-06-11T22:34:54+00:00","mainEntityOfPage":{"@id":"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/"},"wordCount":2034,"publisher":{"@id":"https:\/\/liquidinstruments.com\/#organization"},"image":{"@id":"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/#primaryimage"},"thumbnailUrl":"https:\/\/liquidinstruments.com\/wp-content\/uploads\/2021\/10\/Figure1-2.png","articleSection":["Application notes"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/","url":"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/","name":"Moku Cloud Compile with MathWorks HDL Coder \u2013 Part 2: Simulink - Liquid Instruments","isPartOf":{"@id":"https:\/\/liquidinstruments.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/#primaryimage"},"image":{"@id":"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/#primaryimage"},"thumbnailUrl":"https:\/\/liquidinstruments.com\/wp-content\/uploads\/2021\/10\/Figure1-2.png","datePublished":"2025-04-18T09:11:14+00:00","dateModified":"2025-06-11T22:34:54+00:00","description":"This is Part 2 of the \u201cMoku Cloud Compile with MathWorks HDL Coder\u201d tutorial. Part 1 can be found here. Now, we will use MathWorks\u2019 Simulink to build and","breadcrumb":{"@id":"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/#primaryimage","url":"https:\/\/liquidinstruments.com\/wp-content\/uploads\/2021\/10\/Figure1-2.png","contentUrl":"https:\/\/liquidinstruments.com\/wp-content\/uploads\/2021\/10\/Figure1-2.png","width":1279,"height":705,"caption":"Figure 1: Recommended workflow for Moku Cloud Compile + HDL Coder DSP Design."},{"@type":"BreadcrumbList","@id":"https:\/\/liquidinstruments.com\/application-notes\/cloud-compile-with-mathworks-hdl-coder-pt-2\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/liquidinstruments.com\/"},{"@type":"ListItem","position":2,"name":"Moku Cloud Compile with MathWorks HDL Coder \u2013 Part 2: Simulink"}]},{"@type":"WebSite","@id":"https:\/\/liquidinstruments.com\/#website","url":"https:\/\/liquidinstruments.com\/","name":"Liquid Instruments","description":"","publisher":{"@id":"https:\/\/liquidinstruments.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/liquidinstruments.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/liquidinstruments.com\/#organization","name":"Liquid Instruments","url":"https:\/\/liquidinstruments.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/liquidinstruments.com\/#\/schema\/logo\/image\/","url":"https:\/\/i0.wp.com\/liquidinstruments.com\/wp-content\/uploads\/2020\/10\/BrandMark-Preferred-RGB-Color.png?fit=1000%2C924&ssl=1","contentUrl":"https:\/\/i0.wp.com\/liquidinstruments.com\/wp-content\/uploads\/2020\/10\/BrandMark-Preferred-RGB-Color.png?fit=1000%2C924&ssl=1","width":1000,"height":924,"caption":"Liquid Instruments"},"image":{"@id":"https:\/\/liquidinstruments.com\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/LiquidInstruments\/","https:\/\/x.com\/liquidinstrmnts","https:\/\/www.instagram.com\/liquidinstruments\/","https:\/\/www.linkedin.com\/company\/liquidinstruments\/","https:\/\/www.youtube.com\/c\/LiquidInstruments","https:\/\/vimeo.com\/liquidinstruments"],"hasMerchantReturnPolicy":{"@type":"MerchantReturnPolicy","merchantReturnLink":"https:\/\/liquidinstruments.com\/support\/warranty-repairs-and-service\/"}},{"@type":"Person","@id":"https:\/\/liquidinstruments.com\/#\/schema\/person\/603af464a65f123df56503f020b73dba","name":"joel","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/liquidinstruments.com\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/61d26ea66bf9fb0a2379e1e6e8febb312981e656713bff920c55016dfe82495d?s=96&d=wavatar&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/61d26ea66bf9fb0a2379e1e6e8febb312981e656713bff920c55016dfe82495d?s=96&d=wavatar&r=g","caption":"joel"}}]}},"gt_translate_keys":[{"key":"link","format":"url"}],"_links":{"self":[{"href":"https:\/\/liquidinstruments.com\/wp-json\/wp\/v2\/posts\/9410","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/liquidinstruments.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/liquidinstruments.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/liquidinstruments.com\/wp-json\/wp\/v2\/users\/14"}],"replies":[{"embeddable":true,"href":"https:\/\/liquidinstruments.com\/wp-json\/wp\/v2\/comments?post=9410"}],"version-history":[{"count":16,"href":"https:\/\/liquidinstruments.com\/wp-json\/wp\/v2\/posts\/9410\/revisions"}],"predecessor-version":[{"id":24329,"href":"https:\/\/liquidinstruments.com\/wp-json\/wp\/v2\/posts\/9410\/revisions\/24329"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/liquidinstruments.com\/wp-json\/wp\/v2\/media\/23745"}],"wp:attachment":[{"href":"https:\/\/liquidinstruments.com\/wp-json\/wp\/v2\/media?parent=9410"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/liquidinstruments.com\/wp-json\/wp\/v2\/categories?post=9410"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/liquidinstruments.com\/wp-json\/wp\/v2\/tags?post=9410"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}