ProfiLua
Lua for Profilab

Note #2:
A two's complement does not exist for binary number format:

			
  0b11111111111111111111111111111111 -- 32 times a '1': 4294967295 dec, and not -1 dec.
			

Note #3:
A negative value entered (e.g.: "-0b0111") IS a negative value (-7dec, in this case).

MIDI Interface

That's true. But did you ever try to filter out a range of CONTROL CHANGE or NOTEON/OFF messages, applying some logic to the values received while three or more MIDI devices are sending messages?
Although this is possible in Profilab, it requires tons of blocks and things are slowing down...

Well, this is where ProfiLua's MIDI implementation comes in...

Obviously, controlling Profilab from a MIDI master keyboard would not make much sense (although it is possible). ProfiLua's MIDI implementation clearly targets DAW-Controllers.

These devices contain many potentiometers, sliders, buttons and more...
And if both hands are already in use, what about a foot controller? ;-)

But there's even more:
All professional audio effect racks, filter banks or matrix signal switchers have a MIDI interface. ProfiLua's MIDI implementation can simplify automated audio measurements a lot (At last, that's what I think ;)

Although this example was done with an Akai MPK49 keyboard (Akai names it a "Performance Controller") and the resolution is not that brilliant, you'll get the clue:

Of course, the same can be done with Profilab's built in MIDI blocks. In case you just need a handful of NOTE or CONTROL CHANGE events, the ready to use blocks are probably a better choice, but ProfiLua's MIDI implementation is much more flexible if things get too complicated for "blocks".

A sample project and source code is available (somewhere) below...

Serial Interfaces

• send byte (Byte senden)
• receive byte (Byte empfangen)
• all other :-D

Did you ever try to assemble a sequence of bytes on the fly, send them to a device and decode a varying answer? Especially when the clocking mechanism prohibits a fluent operation?

Even if you managed to "block-code" your special implementation, didn't Profilab require dozens and more blocks just for a literally easy operation?
And even the smallest changes to that "code" usually result in a maximally invasive operation.

Profilab can send fixed numbers or strings and handle fixed answers, but as soon as it gets more complicated, you're lost completely...
Until now ;-)

ProfiLua's serial module can candle all of this.

It supports an unlimited amount of serial ports, knows all baud rates (110..3000000 bits/s), is easy to use and can handle the most complicated stuff in the background (*1*).

You'll probably surprised, seeing 3..5 lines of Lua code (assuming you know how to write them, though) replacing 20..30 blocks...

...

Note to brain:
Provide more examples, here 8)

--------
(*1*) Only one thing is missing yet: hardware handshake

Step by Step Examples

Note:
For simplicity, none of the projects contain "metatables", "coroutines", "anonymous functions", ... or other fancy Lua stuff.

I don't want to scare off potential Lua beginners ;-)

Simple Trigger Block with Hysteresis

The image on the right shows the basic test environment without any DLL. Here follows a minimal step by step instruction on how to implement ProfiLua in this project.

• copy the "ProfiLua_Vxy.dll" into your project directory
• inside Profilab, insert a DLL-IMPORT block and remember its number (e.g.: "DLL1")
• open a real text editor

• DLL1 -> 1.lua
• DLL2 -> 2.lua
• ...

The new block requires three inputs (I) and one output (O):

• I - signal in
• I - trigger low
• I - trigger high...


• O - trigger output

Add these lines to your new file:

			
  gNumInputs  = 3
  gNumOutputs = 1

  InputNames  = {"SigIn","TrigH","TrigL"}
  OutputNames = {"TrigO"}

  function gInputName(channel)
    return InputNames[channel]
  end

  function gOutputName(channel)
    return OutputNames[channel]
  end

  function gSimStart(In)
    return {0}
  end

  function gSimStop(In)
  end

  function gCalculate(In)
    return {0}
  end
			

• double click the DLL block in Profilab
• select "IMPORT DLL", choose "ProfiLua_Vxy.dll"

Try connecting the "CONSOLE" input to high (or fixed 5V value) and add a "print()" instruction to the function "gCalculate()", right before the line containing "return {0}".

You can even do this while Profilab is running:

			
  function gCalculate(In)
    print(In[1],In[2],In[3])
    return {0}
  end
			

For a nicer print, you may wish to try:

			
  function gCalculate(In)
    print(string.format("S:%3.1f; H:%2d; L:%2d",In[1],In[2],In[3]))
    return {0}
  end
			

			
  function gCalculate(In)
    io.write(string.format("Sig: %3.1f;   TH: %2d;   TL: %2d\n",In[1], In[2], In[3]))
    return {0}
  end
			

			
  tState = 0
  pState = gLOW;

  function gCalculate(In)
    io.write(string.format("Sig: %3.1f;   TH: %2d;   TL: %2d\n",In[1], In[2], In[3]))

    if (In[1] > In[2]) and (tState == 0) then
      pState = gHIGH
      tState = 1
    elseif (In[1] < In[3]) and (tState == 1) then
      pState = gLOW
      tState = 0
    end

    return {pState}
  end
			

If the trigger state is "0", we just need to wait until "In[1] > In[2]". This changes both, the output pin as well as the trigger state, to high.
The reverse operation, clearing the pin, will be executed if the input signal "In[1]" is lower than the lower trigger threshold "In[3]", while the trigger state is set to "1".

You can download example#2 here.

Simple Number to BIN or HEX conversion (string)

Is there anything easier than this?

You can download example#3 here.

			
  gNumInputs  = 1
  gNumOutputs = 2

  InputNames  = {"Num"}
  OutputNames = {"$BIN","$HEX"}

  function gInputName(channel)
    return InputNames[channel]
  end

  function gOutputName(channel)
    return OutputNames[channel]
  end

  function gSimStart(In)
    return {"",""}
  end

  function gSimStop(In)
  end

  function gCalculate(In)
    return {"0b"..probit.tobin(In[1]),"0x"..probit.tohex(In[1])}
  end
			

Probability Density Function (PDF)

You can download example#4 here.

			
  gNumInputs  = 3
  gNumOutputs = 1

  InputNames  = {"x","sigma","my"}
  OutputNames = {"PDF"}

  function gInputName(channel)
    return InputNames[channel]
  end

  function gOutputName(channel)
    return OutputNames[channel]
  end

  function gSimStart(In)
    return {0}
  end

  function gSimStop(In)
  end

  function gauss(x,s,m)
    if s < 0.01 then
      return 0
    end
    return (1/(s*math.sqrt(2.0*math.pi)))*math.exp(-0.5*math.pow((x-m)/s,2))
  end

  function gCalculate(In)
    return {gauss(In[1],In[2],In[3])*100}
  end
			

Including multiple ProfiLua DLLs

If you include a ProfiLua DLL only once, you only have to care about ProfiLab's DLL number. (Note: If you delete a DLL inside Profilab, all DLLs are renumbered! Keep this in mind.)

What about including multiple instances of "ProfiLua.dll"?

Due to the internal DLL handling inside Profilab and ProfiLua's internal implementation of Lua, you can NOT LOAD THE SAME DLL MULTIPLE TIMES, but there's a simple workaround available:

The distribution includes several DLLs:

			
  ProfiLua_Vxy-A.dll
  ProfiLua_Vxy-B.dll
  ProfiLua_Vxy-C.dll
			

I do not recommend loading more than three instances of ProfiLua. Even if separating different functions might please your eyes, a single instance of ProfiLua can do all the work.

Nevertheless, if you are going to include more than one ProfiLua DLL, do it like this --------->

You can download example#5 here.

Handling Zeros in Strings

At a glance, the example on the right might look complicated, but this is the only way of passing more than one value at once. Profilab only allows "numbers" or "strings".
Note: A C-string inside Profilab is of type "char[]" (or "*char", if you like pointers). Its values can not exceed 0-255!

A special problem arises if your Lua table (or string) contains zeros. These need some proper handling.

Inside ProfiLua, we just convert a "0" (zero) and a "16" (sixteen) to

• 0x00 -> 0x10 0xFF
• 0x10 -> 0x10 0x10

You can download example#6 here.

Little Clock State Machine

			
  for i in 1,10 do
    pOut = 1
    pOut = 0
  end
			

Just a stupid example:

  pOut = gLOW  -- initialized as Profilab loads the ProfiLua script

  function gCalculate(IPins)
    -- ...
    -- calculate whatever you like
    -- ...

      if pOut == gLOW then
        pOut = gHIGH
      else
        pOut = gLOW
      end
		
    return {pOut}
  end
			

You can download example#7 here.

Saving gPUser values on exit

It does not matter, where or when those values change, e.g.:

  function gSimStop(In)
    gPUser[1] = In[3]
    return {0}
  end
			
			
  function gSimStop(In)
    gPUser[2] = 666
  end
			

You can download example#8 here.

Real World Example

This functionality could not have been implemented with plain Profilab blocks...

You can download example#100 here.

MIDI Basics

  in  = promidi.CountDevices(MIDIIN)
  out = promidi.CountDevices(MIDIOUT)
			

Note that all in- and outputs are stored in separate lists!
An input "1" might address a different device than output "1".

To query the name of a device, type:

  iname = promidi.GetMidiInName(number)
  oname = promidi.GetMidiOutName(number)
			

The following code prints out a list of all available output devices to the debug console (if enabled):

			
  for i=0, promidi.CountDevices(MIDIOUT)-1 do
    print(i,promidi.GetMidiOutName(i))
  end
			

To open or close a device, execute:

  retcode = promidi.OpenMidiIn(number)
  retcode = promidi.OpenMidiOut(number)

  retcode = promidi.CloseMidiIn(number)
  retcode = promidi.CloseMidiOut(number)
			

To simplify opening a specific device, a name-lookup function might be helpful:

			
  function MidiFindFirstByName(dir, name)
    local i
  
    if dir == MIDIIN then
      for i=0, promidi.CountDevices(MIDIIN)-1 do
        if string.match(promidi.GetMidiInName(i),name) ~= nil then
          return i
        end
      end

    elseif dir == MIDIOUT then
      for i=0, promidi.CountDevices(MIDIOUT)-1 do
        if string.match(promidi.GetMidiOutName(i),name) ~= nil then  
          return i
        end
      end
    end

    return -1
  
  end
			

It is indeed a good practice to open all devices inside gSimStart() and close them in gSimStop() respectively:

  -- !!!WARNING: MINIMAL CODE AHEAD!!!

  devIN  = -1
  devOUT = -1
  ------------------------------------------------------------------------------  
  -- gSimStart
  ------------------------------------------------------------------------------
  function gSimStart(In)

    if promidi.OpenMidiIn(3) == 0 then
      devIN = 3
    end

    if promidi.OpenMidiOut(2) == 0 then
      devOUT = 2
    end

    return {}
    
  end

  ------------------------------------------------------------------------------
  -- gSimStop
  ------------------------------------------------------------------------------
  function gSimStop(In)
    
    if devIN >= 0 then
      promidi.CloseMidiIn(devIN)
    end

    if devOUT >= 0  then
      promidi.CloseMidiOut(devOUT)
    end
    
  end
			

And just in case you are curious, it indeed is possible to open more than one in- or output:

  -- !!!WARNING: MINIMAL CODE AHEAD!!!
			
  devIN1  = -1
  devIN2  = -1
  devIN3  = -1
  ------------------------------------------------------------------------------  
  -- gSimStart
  ------------------------------------------------------------------------------
  function gSimStart(In)

    if promidi.OpenMidiIn(0) == 0 then devIN1 = 0 end
    if promidi.OpenMidiIn(1) == 0 then devIN2 = 1 end
    if promidi.OpenMidiIn(2) == 0 then devIN3 = 2 end

    return {}
    
  end

  ------------------------------------------------------------------------------
  -- gCalculate
  ------------------------------------------------------------------------------
  function gCalculate(In)
    local ev1,ev2,ev3
  
    ev1 = promidi.GetMessage(devIN1)
    ev2 = promidi.GetMessage(devIN2)
    ev3 = promidi.GetMessage(devIN3)

    ...

    return {}
  
  end

			

After a device has been opened, the following functions exist for sending or receiving MIDI messages or events:

  -- sending messages to OUT devices:
  retcode = promidi.SendMessage(number, channel, key, velocity, EVENT)  

  -- reading messages from IN devices:
  message = promidi.GetMessage(number)
			

• a Lua table with four entries {event, channel, data1, data2}
• nil, if there's no event available (or other, unusual stuff happened...)

ProfiLua supports:

• 0x90 NOTEON
• 0x80 NOTEOFF
• 0xB0 CONTROL CHANGE (can do almost everything)
• 0XE0 PITCH BEND (only useful as input)

Play a note (middle C [60dec]) on device 1, MIDI channel 3 with a velocity of 100:

  promidi.SendMessage(1, 3, 60, 100, NOTEON)
			

Light up a green, a red and a yellow LED on the Novation Launchpad, assuming it is available as output device number 2 (Launchpad uses MIDI channel 1):

  promidi.SendMessage(2, 1, 0, 0b00111100 , NOTEON) -- green upper left  
  promidi.SendMessage(2, 1, 1, 0b00001111 , NOTEON) -- red
  promidi.SendMessage(2, 1, 2, 0b00111111 , NOTEON) -- yellow
			

Read Akai MPK49 (device number stored in devIN) events and determine "K1-3" potentiometer values:

  function gCalculate(In)
    local ev
  
    ev = promidi.GetMessage(devIN)
    if ev ~= nil then
      if ev[1] == CTRL and ev[2] == 1 then
        if ev[3] == 0x16 then print("K1:",ev[4]) end
        if ev[3] == 0x17 then print("K2:",ev[4]) end  
        if ev[3] == 0x18 then print("K3:",ev[4]) end
      end
    end
  
    return {}
  
  end
			

The only drawback of MIDI equipment, at least if it's used as an input device is, that the incoming values only have a range of 0..127.

What is to do if you have unknown equipment or no manual?
These four lines of ProfiLua code prints all events from a device with number <devIN>:

  -- assuming:
  --   - MIDI device number stored in <devIN>
  --   - MIDI device already opened (preferably in gSimStart())    		
  --   - no outputs (gCalculate returns an empty table)

  function gCalculate(In)
    local ev

    ev = promidi.GetMessage(devIN)
    if ev ~= nil then
      print(ev[1], ev[2], ev[3], ev[4])
    end
  
    return {}
  
  end
			

If you need to do more complex analyses or probing of MIDI messages, there's no way past MIDI-OX ==>

MIDI: Akai Slider Example

  AkaiStates = {0,0,0,0,0,0,0,0}
  ---------------------------------------------------------
  -- gCalculate
  ---------------------------------------------------------
  function gCalculate(In)
    local ev
    
    ev = promidi.GetMessage(devIN)
    if ev ~= nil then
      if ev[1] == CTRL and ev[2] == 1 then
        if ev[3] == 0x16 then AkaiStates[1] = ev[4] end
        if ev[3] == 0x17 then AkaiStates[2] = ev[4] end
        if ev[3] == 0x18 then AkaiStates[3] = ev[4] end
        if ev[3] == 0x19 then AkaiStates[4] = ev[4] end
        if ev[3] == 0x0c then AkaiStates[5] = ev[4] end
        if ev[3] == 0x0d then AkaiStates[6] = ev[4] end
        if ev[3] == 0x0e then AkaiStates[7] = ev[4] end
        if ev[3] == 0x0f then AkaiStates[8] = ev[4] end
      end
    end

    -- Notice that "AkaiStates" already is a table, hence it  
    -- does not require {} around it...
    return AkaiStates
    
  end
			

You can download example#90 here.

Formatted Output to File

  754 b387 9735.0 0b00000000000000000101010110100101
  805 16a2 9735.0 0b00000000000000000101010110101011
  805 16a2 2824.7 0b00000000000000000101010110101011
   27 054a 6811.5 0b00000000000000000000111010111101
  499 b7a4 6811.5 0b00000000000000000000101110011010
  499 b7a4  971.6 0b00000000000000000000101110011010
  202 2e4d  971.6 0b00000000000000001010110001000010
  202 2e4d 7988.9 0b00000000000000001010110001000010
  353 c106 4902.3 0b00000000000000001110101110000101
  424 0a6e 4902.3 0b00000000000000001101110000101100  
			

The code in gCalculate():

  written = 0
  ------------------------------------------------------------------------------  
  -- gCalculate
  ------------------------------------------------------------------------------
  function gCalculate(In)
    local i
    
    if fout ~= nil and In[5] >= gISHIGH then
      fout:write(string.format("%3d",In[1])..separator)
      fout:write(string.format("%04x",In[2])..separator)
      fout:write(string.format("%6.1f",In[3])..separator)
      fout:write(string.format("%s","0b"..probit.tobin(In[4],32)))  
      fout:write("\n")
      written = written + 1
    end
    
    if fout == nil then
      return {gLOW, written}
    else
      return {gHIGH, written}
    end
    
  end
			

You can download example#91 here.

Serial Basics

Creating a Handle

Before you can do anything else, you need to call

  portHandle = proserial.Mount()
		

The returned value "portHandle" is

   0, if an error occured
  >0, if the handle is valid
		

Every other function needs this "handle".

Checking Ports

To check if a port is availabe and free for use, call:

  isAvailable = proserial.CheckPort( handle, port )  
		

The return value "isAvailable" contains:

   0, if the port is NOT available
   1, if the port exists and is not used
		

Configuring Ports

By default, all serial interfaces' parameters are set to 19200 bits/s, "8N1".
Eight bits, no partity ans one stop bit.

If you need other baud rates, call

  ret = proserial.Config(handle, -- configures the COM port referenced by "handle"  
                           baud, -- baud rate (300..3000000 bits/s)
                           bits, -- number of bits (5, 6, 7, 8)
                         parity, -- parity (0, 1, 2 -> NONE, ODD, EVEN)
                           stop) -- number of stop bits (1, 2)
		

Instead of using the numbers 0, 1 or 2 to specify the parity, you may use one of these global variables instead:

  PARITY_NONE  
  PARITY_ODD
  PARITY_EVEN
		

An example for setting the port to 115200 bits/s, "8N1":

  ret = proserial.Config( handle, 115200, 8, PARITY_NONE, 1 )  
		

The return values of the Config() function are:

   0, if an error occurred
   1, if everything went just fine
		

Valid baud rates in bits/s are:

      110     4800     56000     500000    3000000 
      300     9600     57600     512000
      600    14400    115200     921600 
     1200    19200    128000    1000000 
     2400    38400    256000    2000000
		

Opening Ports

Open a port with

  ret = proserial.Open( handle, port )  
		

Where "port" is the number of the COM port you wish to use (COM1: 1, COM3: 3, ...).

The return values of the Open() function are:

   0, if an error occurred
   1, if the port is now open and ready to send or receive data  
		

Sending Data

To send data over the serial interface, use

  ret = proserial.Send( handle, data )  
		

The second argument "data" can be:

                        a number: data = 123
                        a string: data = "*burp*"
   a table of numbers or strings: data = { 123, "*b", "urp*", 23 }  
		

Table items are sent in order of appearance.
Tables inside the table are not allowed, they will not get sent.

Notice that the Send() function can handle zeros (0)!

The return values of the Open() function are:

   0, nothing was sent (for whatever reason)  
  >0, number of bytes sent
		

Receiving Data

ProfiLua always receives any incoming byte in the background and stores it in memory. There's no limit to the size of data that can be received, except the amount of RAM available on your system.
You don't need to care about anything. If the port is opened, all incoming data will get saved.

You can read a byte from this memory buffer with:

  data = proserial.ReadByte( handle )
		

The call of ReadByte() can return:

  <0    : the buffer is empty
  0..255: the numerical value of the byte received
		

If the return value exceeds 255, you're drunk and doing it wrong...

Checking the Buffer

If you want to wait until a specific number of bytes was received, you can check the amount of data in the buffer with

  bytesInBuffer = proserial.BufferCount( handle )
		

The return values of this function are:

   <0, an error occurred (port no opened, etc...)
  >=0, the amount of data bytes in the buffer
		

Deleting the Buffer

If ever need to delete the complete receive buffer, just call:

  ret = proserial.BufferFlush( handle )
		

The buffer is now completely emtpy.
This function always returns a one (1).

Closing the Port

To close the serial port, simply call:

  ret = proserial.Close( handle )
		

The return values of the Close() function:

   0, an error occurred
   1, the port is closed; sending or receiving data is impossible
		

Notice that the "handle" is still valid and can be used to open, configure, ... the port again.

Deleting the Handle

A call to this function will destroy the handle:

  ret = proserial.UnMount( handle )
		

The return values of UnMount() can be;

   0, if an error occurred
   1, if the handle was destroyed successfully
		

As of now, the "handle" is invalid and can not be used anymore.

Simple Serial Interface

Although this does nothing else but send Lua numbers, strings or tables by the push of a button, the provided code might come in handy as a mini-reference on how to use the serial interface.

Set the COM port of your serial interface in the "1.lua" file around line ~15

  -- SET YOUR COM PORT HERE  
  COMPORT = 6
			

Make sure to watch the console window, because most of the stuff happens right there!

The code in gCalculate():

  ------------------------------------------------------------------------------  
  -- gCalculate
  ------------------------------------------------------------------------------
  function gCalculate(In)
    -- on top for better visibility
    local randLetter
    local randString
    local randTable
    local ch

    -- send number button
    if CheckButtonPressed( In[1], 'butTrigNumber' ) == 1 then
      randLetter = 64 + math.random(26)
      if proserial.Send( portHandle, randLetter ) > 0 then
        print("SENT " .. randLetter .. " -> " .. string.char(randLetter) )
      else
        print("ERROR sending " .. randLetter )
      end
    end

    -- send string button
    if CheckButtonPressed( In[2], 'butTrigString' ) == 1 then
      randString = '*burp*'
      if proserial.Send( portHandle, randString ) > 0 then
        print("SENT " .. randString )
      else
        print("ERROR sending " .. randString )
      end
    end

    -- send table button
    if CheckButtonPressed( In[3], 'butTrigTable' ) == 1 then
      randTable = { 65, 66, 67, 'a', 'b', 'c', "*burp*" }
      if proserial.Send( portHandle, randTable ) > 0 then
        io.write("SENT ")
        local i,v
        for i,v in pairs( randTable ) do
          io.write( v )
        end
        print()
      else
        print("ERROR sending the table")
      end
    end

    -- read button
    if CheckButtonPressed( In[4], 'butTrigRead' ) == 1 then
      print("RECEIVED ")
      while 1 do
        ch = proserial.ReadByte( portHandle )
        if ch < 0 then
          break
        else
          print("  " .. ch .. "  " .. string.char(ch) )
        end
      end
    end
    

    return { portMountedAndOpen, proserial.BufferCount( portHandle ), 0 }
  end
	

You can download example#10 here.

FAQ

General

Q: Why did you built this?

In detail:

Initially, ProfiLua was built as an universal USB device interface, including a commercial USB driver (...). I stripped down the non-free parts of it and, well, here it is...

Some day, libusb-win32 might get built in, but not until a stable version is released.

Q: What are the advantages? Why not code in plain C/C++/DELPHI?

In detail:

You only need to edit a simple text file. No compiler is required. Changes will immediately be available after simply stopping and restarting the Profilab project. You can even edit the text file while Profilab is running.

Lua has a lot of features, just to name a few:

• coroutines (sort of multi-tasking)
• proper tail calls (allow unlimited recursion)
• up-values (lexically scoped)
• anonymous functions
• first-class values (everything can be an argument)
• weak tables (references to other objects)
• metatables and meta-methods (object orientated; operator overloading; ...)
• garbage collector
• ...

Q: Is Lua/ProfiLua fast?

In detail:

Due to the fact that Lua is an interpreting language, it will slow things down. How slow? Form your own opinion ;)

Q: I wrote a Lua script and Profilab crashes!

In detail:

Running ProfiLua requires an error-free script!
All errors within ProfiLua (e.g. all runtime errors, calling a function that does not exist, trying to add a number to a string, and, and, and...) will crash Profilab!
So will memory leaks (Lua stack over- or underflows), kernel panics, and, and, and...

Even if Lua contains a byte compiler, it is still an interpreting language and most programming errors will show up while it is running...

This might get improved in a future version...

SAVE YOUR PROFILAB PROJECT BEFORE EXECUTING IT!
SAVE YOUR PROFILAB PROJECT BEFORE EXECUTING IT!
SAVE YOUR PROFILAB PROJECT BEFORE EXECUTING IT!

Q: Is it stable?

In detail:

There's no way around improving your Lua skills...
Any or all of the errors that make Profilab crash, are caused by you (and my personal freedom of not-including any sanity checks (Lua stack, etc...) to the code ;-)

SAVE YOUR PROFILAB PROJECT BEFORE EXECUTING IT!
SAVE YOUR PROFILAB PROJECT BEFORE EXECUTING IT!
SAVE YOUR PROFILAB PROJECT BEFORE EXECUTING IT!

Project Files

Q: I loaded another ProfiLua project, residing on a different path, and nothing happened!?

In detail:

Profilab remembers the last path, from where a DLL was loaded.
If you already opened a ProfiLua project, you need to restart Profilab. Otherwise the corresponding ProfiLua file "x.lua" can not be opened.

Q: Can I use ProfiLua for compiled projects?

In detail:

Remember to copy the ProfiLua files "x.lua" to the EXE directory.

Strings

Q: Does ProfiLua support "0s" (zeros) in strings?

In detail:

Due to Profilab's implementation of the "CCalculateEx()" function

  void CCalculateEx(double *PInput, double *POutput, double *PUser, uchar **PStrings);  
			

A workaround would be using the string REPLACE block, prior of feeding the string to a ProfiLua DLL-block, with a replacement like:

			
  0x00 -> 0x10 + 0xff
  0x10 -> 0x10 + 0x10
			

Console

Q: Can I have multiple console windows? Probably by loading the DLL more than once?

In detail:

Even if you include the DLL more than once (*1*) only a single "CONSOLE" pin needs to be set, preferably at the first ProfiLua DLL block. All other instances may print to the console window too.

(*1*) READ NOTES BELOW! ("Multiple DLLs").

Q: Does the console interfere with Profilab?

In detail:

Printing (a lot of stuff) to the console might decrease the performance of Profilab, but only a little. Usually, "io.write()" is faster than a "print()".

You can pause Profilab/ProfiLua execution by pressing the "PAUSE" key (console must have focus) and resume by hitting "SPACE". Sometimes, this comes in handy...

Even if the console is disabled, any remaining "io.write()" or "print()" call will reduce execution speed. The console is only a debug feature!

Multiple DLLs

Q: Can I rename the DLL and include it multiple times?

In detail:

Multiple instances of ProfiLua, loaded in Profilab, require a unique internal "DLL name". Renaming the file is not enough.
The compiled binary distribution of ProfiLua comes with a set of different DLLs ("_A", "_B", ...) that can be used for this.

Usually, a single DLL is all you need. You can have as many in- or outputs as you like.

Q: Can the console READ from stdin?

In detail:

Yes, but reading from stdin, e.g. by calling "io.read()", blocks Profilab until a character was received. There's an experimental non-blocking function available inside ProfiLua which might be functional in a future version:

  prolua.getkey()
			

Changes

v0.9b

• Values saved to gPUser table will be available on next start of the project.
• Fixed some severe Lua stack bugs in CSimStop(), affecting arguments of gSimStop().

v0.9c

• Now supports MIDI devices.

v1.0

• Now full support for serial interfaces ("COM-ports").

v1.0a

• serial interface: added 500000 and 512000 bit/s

Download

ProfiLua

Note #1: Examples may contain OLDER ProfiLua DLLs!
Note #2: Most of the examples are also available in the old distribution below!
DOWNLOAD: profilua_example1.zip Example #1: simple demo
DOWNLOAD: profilua_example2.zip Example #2: hysteresis trigger
DOWNLOAD: profilua_example3.zip Example #3: number to BIN and HEX strings
DOWNLOAD: profilua_example4.zip Example #4: Probability Density Function
DOWNLOAD: profilua_example5.zip Example #5: including multiple DLL instances
DOWNLOAD: profilua_example6.zip Example #6: Lua table with zeros to Profilab string
DOWNLOAD: profilua_example7.zip Example #7: Clock state machine
DOWNLOAD: profilua_example8.zip Example #8: Saving gPUser values (v0.9b+)

DOWNLOAD: profilua_example90.zip Example #90: MIDI: Query MIDI sliders, MPK49 (v0.9c+)
DOWNLOAD: profilua_example91.zip Example #91: Formatted output to file

DOWNLOAD: profilua_example10.zip Example #10: Simple Serial Interface Example


DOWNLOAD: source code on Github always up to date


OLDER RELEASES (including examples):

DOWNLOAD: ProfiLua_V09c.zip V0.9c (04/2011)

EXTRA:
DOWNLOAD: profilua_example100.zip Example #100: JTAG-Scanner firmware tester

Lua

Disclaimer

Updates