Custom 'My step' Xcos block for MicroDAQ

Defining block functionality

Before MicroDAQ Xcos block creation a requirements defining functionality and block interface has to be defined. Our new block will be described by the following properties:

• name - describes block function, should be unique, created block macro will have provided name with prefix 'mdaq_'
• description - help for user, should provided (if needed) short description of block properties
• parameter name - names of block parameters which can be modified during Xcos diagram creation
• parameter size - size of block parameters
• parameter default value - default values of block parameters
• inputs - definition of block inputs
• outputs - definition of block outputs
• use_sim_script - defines how simulation mode will be performed (from C source or Scilab _sim.sci script)

Our custom block will be named 'My_step', it has three parameters 'Step time', 'Initial value', 'Final value' and 'Terminate value'. All block parameters are scalars, and has default values: 'Step time' - 1, 'Initial value' - 0, 'Final value' - 1, 'Terminate value' - 0. Block shall have one output port, output port size is 1. Block doesn't have input ports.

Custom 'Step' block step by step

• Initialize MicroDAQ block structure with mdaqBlock() function

block = mdaqBlock() // block = // name: "new_block" // desc: "Set new_block parameters" // param_name: [2x1 string] // param_size: [2x1 constant] // param_def_val: list // in: 1 // out: 1 // use_sim_script: %f

• Set block properties:

  • name - our block will have 'My_step', toolbox defines Step function (mdaq_step macro already defined), block name length is limited to 24 signs
  • desc - if not provided 'new_block' in default description string will be replaced with block name
  • param_name - this parameter holds block parameters names, it should be provided as an array of strings. Provided names will be used in generated block C code
  • param_size - our block will have four scalar parameters, have to be defined in the same order as 'param_name'
  • param_def_val - default block parameters values are organized as a list and have to be defined in the same order as 'param_name'
  • in - in case of our block we should provide an empty array - block doesn't have input ports
  • out - our block will have one output port and its size will be 1 - scalar
  • use_sim_script - if false (%F - by default), our block will use compiled C source in simulation mode. It guarantees the same code on host (simulation mode) and target (code generation) side. If parameter is set to true (%T) then (block.name)_sim.sci script will be executed during simulation mode.

  block.name = "My_step"; block.param_name = ['Step time' 'Initial value' 'Final value' 'Terminate value']; block.param_size = [ 1 1 1 1 ]; block.param_def_val(1) = 1; // 'Step time' default value block.param_def_val(2) = 0; // 'Initial value' default value block.param_def_val(3) = 1; // 'Final value' default value block.param_def_val(4) = 0; // 'Terminate value' default value block.in = []; // block doesnt'have input port block.out = [ 1 ]; // one output port - size 1 block.use_sim_script = %F; // Use compiled C source instead of Scilab script

• Generate and add block to MicroDAQ User palette

mdaqBlockAdd(block);

This step will generate block C code. Also block macros defining block properties and block behaviour in simulation mode ()'_sim' postfix) are generated. Functions generate following files:

• mdaq_my_step.sci - defines block properties and block appearance
• mdaq_my_step_sim.sci - Scilab code which can be used in simulation mode (not for code generation)
• mdaq_my_step.c - C code containing DSP code used for code generation

Generated C code file is compiled, resulting DSP library will be used to build DSP executable created from Xcos diagram containing 'My_step' block.

• Open for edit mdaq_my_step.c file
• Add your C code.

  Generated C source code contains 'init', 'inout' and 'end' functions. Function 'init' is executed when model is loaded on target. This function can initialize peripherals, allocate resources for block etc. The 'inout' function contains code which will be executed on every model step. The 'end' function is executed when model execution is done or it is stopped with Xcos 'Stop' button

  if (get_scicos_time() > step_time) *y1 = final_value; else *y1 = initial_value;

  The code uses get_scicos_time() function to get current simulation time. Depending on step_time block parameter block output (*y1) is set to final_value or initial_value.

• Build modified C code:

  mdaqBlockBuild());

  If errors found during compilation correct them and run mdaqBlockBuild() again.

• Restart Scilab - in order to reload 'MicroDAQ User' palette MicroDAQ toolbox for Scilab has to be reloaded.
• Start Xcos and open palette browser and locate 'MicroDAQ User' block category.
  

• Create Xcos diagram containing newly created 'My_step' Xcos block
  

• Create 'Superblock' by selecting 'My_step', 'SIGNAL' and Scope block.
• Change model sample rate to 0.01 by editing 'Period' Clock block parameter. Set 'Initialisation Time' to 0
• Save model and build and load model by selecting Tools->MicroDAQ build and load model from Xcos menu
• Start model with Xcos 'Start' simulation button
  

• Check different block parameters

'My_step' block in simulation mode

If block.use_sim_script is set to false (%F - by default) then C source will be compiled to shared library which will be used in simulation mode. It guarantees the same code on host (simulation mode) and target (code generation) side. In order to use this option the external C compiler is required. List of supported compilers can be found at: https://help.scilab.org/doc/5.5.2/en_US/supported_compilers.html. If compiler cannot be provided or user want to have different behaviour in simulation mode, the _sim.sci script can be used instead.

Generated block files can be used to implement block code for standard simulation mode. In order to add code for simulation mode generated mdaq_my_step_sim.sci file needs to be edited. The mdaq_my_step_sim.sci file contains code which will be executed in simulation mode. Function mdaqBlockAdd() generates file which contains block parameters variables which has to be used to change block output.

Generated mdaq_my_step.sci file:

Similar to C source file we have to add Scilab code which will be performing 'step' function.

• Locate and open generated mdaq_my_step_sim.sci file

• Add the following code to 'Output Update' case in generated mdaq_my_step_sim.sci file

  if scicos_time() > step_time then block.outptr(1) = final_value; else block.outptr(1) = initial_value; end

• In order to use modified code clear old mdaq_my_step_sim function:

  clear mdaq_my_step_sim;

• Compile modified file with:

  mdaqBlockBuild();

• Go back to Xcos and run simulation (don't generated DSP application)