NWare 1.5.4 Beta is available

This is an exciting update, thanks for your participation in helping make sure the release is as good as we can make it.  Please report any problems as soon as possible.  Include as much detail as possible on how to reproduce the issue.  We are at a feature freeze now. 

Download the release from here:

peaveyoxford.com/beta/NWare-1.5.4.0201-Beta-4.msi

Features:

New Acoustic Echo Cancellation card, the NIO-AEC.
    Eight analog mic/line-level audio input channels with 24 bit A/D
    Eight channels of wideband acoustic echo cancellation
    Acoustic echo cancellation can be applied to mic input or internal audio input channels (from NION)
    Look for complete documentation in the help file

Plugins 
    Plugins are a much more powerful replacement for the User Devices.  Plugins combine signal processing, control, images, and python code and can easily be imported, exported and managed.

    The plugins are part of the device tree and can be organized using folders.  When you install NWare your old User Devices are automatically converted and added under Plugins in the Device Tree.

    To create a plugin, select what you want included on the design pane and then choose Tools/Define Plugin.  Enter the name for your plugin.  If you want the plugin to appear in a folder, type the folder name followed by a forward slash and the plugin name.  You can nest sub-folders, for example "cluster processing/3 way/large".  This creates a plugin called "large" in the folder "3 way", which is in turn in the folder "cluster processing".  Not that you can select and modify previously defined plugins to save typing.

    To add a plugin to your design, simply drag it in as you do all devices. 

    Another important new feature is that you can now easily import and export plugins.  To export a plugin, right click on it in the device tree and choose "export".  This is also how you can rename and delete a plugin.  Enter the name you want for the plugin and click "save".  The plugin will be saved with the extension ".npp" (NWare Project Plugin).  You can also select and export a folder wilh a collection of plugins as a single NPP file.  To import a plugin file, select "Tools/Import Plugins..."  The new plugin or folder of plugins will be added to your plugins device tree.  Any images or Live Python code (see below) are also included in the exported file.

    We've created an example plugin library called "Peavey.npp".  You can download it from here:

peaveyoxford.com/beta/Peavey.npp

Examples include:
    Logic devices with state indicators on all input and outputs.  These also demonstrate the use of embedded images (the logic symbol is on the device).
    Easier to use and buttons and LEDs
    An example of a mixer with delay controls at each crosspoint.
    A parametric EQ with a "Q" control in place of the bandwidth control.  This is an example of embedded Live Python (the Q to BW computation).
    A real time clock device.
    A digital clock using the above real time clock device as well as Python and an image control.
    A DVD player controller.
    An example showing how you can lock part of your device away, including the python code.

    Be sure to explore these pre-built devices.  Some you need to select and un-group to see their parts.  Others need to be opened, and then "show tabs" to un-hide the schematic.
     
    Note that by using locked pages, you can design and share devices without the recipient being able to examine the design, including any python code.

Things you can do with plugins:
    Customize devices to always appear the way you want, with the default values you want.
    Build, reuse, and distribute your own custom design elements and title blocks.
    Create devices to control other products.
    Distribute, either freely or for money, the devices you create.

Note the following are NOT saved in plugins:
    Python scripts not part of Live Python devices.
    Preset datasets.
    Audio .wav files.
   
Live Python
    Live Python is a new way to create and use Python code on running systems. You can edit, test, and modify your python code without needing to re-deploy. 

    Live Python also includes support for external script editors. By default it launches WordPad but just about any editor should work. You can adjust the default editor under User Preferences.  Here are two we've tried that seem pretty good:

http://notepad-plus.sourceforge.net/uk/site.htm
http://www.pnotepad.org/

    All scripts created with the Live Python device are encrypted. If you place your device on a locked page other users cannot see the code by looking at the project (or plugin) file.  Also, since it is simply a control value, you can do some tricky things like change the code with a preset (be careful!)  Note that that this also means that, just like all other controls, you cannot modify it unless you are connected or emulated.

    Usage: Unlike the plugins, this does not replace the previous method for using Python, but adds new capabilities.  When you drag in and open a Live Python device (called "Python Live" in this release), you will see a document icon in the upper left.  If you double click on this, your external editor will launch with the contents of the script block, if any. When you save, the Live Python device is automatically updated with the new code.  Note that because this happens when you are connected to a running system your new script will be executed immediately on the running system.

    Please see the section at the end for information on how to use threaded scripts with the Live Python device.

Other Improvements:
- Improved Crest Ci and CKi amplifier devices including support for individual channel RTLM training.
- NION firmware versions are now checked at deploy time for consistency.
- New device for controlling the Furman F1500 UPS.
- RATC and ControlMatrix for Windows can now be independently configured.
- A button configured to trigger a page change can now trigger a page change when control wired instead of just when clicked with a mouse.  In addition, we've added a new check box option to the control properties called "force visible".  Normally, if a button is used to activate a tab change, the change only happens if the window containing the page is visible.  If you check this, the button will change tabs if necessary and open the block containing the tab.  This means you can create an "index" page of buttons to instantly jump anywhere in a project.
- A warning dialog box appears when duplicate control aliases are created.
- Windows 7 is now supported.

Bug Fixes:
- You can now wire to controls and devices that are grouped with other objects.
- Various web UI fixes including FTP service enable and CAB control interface.
- The textbox-scrollable control style now is scrollable.
- Eliminated a pop on the analog outputs of a NION during shutdown.
- FTP file listings did not work with some FTP client applications.
- CHIMP now works under Windows 7 and Vista

Known Issues:
- There are issues with un-install not un-installing everything.
- A command window with a warning appears when you connect to a project with kiosk.  We are currently testing a fix for this.
- Under Windows 7, the log text sometimes goes to a separate command window.  This does not affect operation, we are investigating. 
- If you copy items from one project to another project using copy/cut and paste, the images in the selected objects are not transferred.  This has always been the case.  However, as we are using images in many of the plugin examples, this becomes more obvious.  For example, if you drag in a plugin logic device, then copy it to another project, the logic icon displays a (tiny) purple error message.  The workaround is to drag in an identical plugin.  This brings in the image and repairs all the (similar) icons.  You can then delete the plugin you just dragged in.  Or, instead of using copy/cut paste, define the things you want to copy as a temporary plugin and drag them into the new project. 
- If you define a plugin while multiple copies of NWare are running, the new plugin is not available in the other copies until they are re-started.
- The installer package is larger than before.  We plan on also distributing a minimal NWare installer that only supports the NION.

Notes on writing Live Python scripts

    In theory any Python script that worked before will work with the new Live Python device. This includes threaded scripts which have all the same caveats as before along with some  additional ones. Please note that the state variable persists across instances of the script. The last value of the state variable will be present when the updated script is run.

    In order to support changing out scripts at run-time two new Nion specific python commands have been added which scripters will want to consider when they write Live Python scripts. These new methods are called: event.wait_should_exit() and event.wait_input_should_exit(). These are similar to the existing event.wait() and event.wait_input_change() but whereas those methods simply exit the script without warning these new methods return control to the script so the user can clean up if necessary. If clean up is not necessary then the existing methods can be used.

    These new methods need to be called from within the scripts main loop to check for script termination. If these methods return true (non-zero) the user should do any clean up necessary and exit the script promptly.

Examples of where users might need to consider cleaning up their scripts include:
    State variable - If you want to initialize the built-in state variable to a safe value before the script runs again you can do this before exiting
    Sockets - If you are listening on a socket with a specific port which you will want to reuse you may want to gracefully close and release this resource before exiting.
    Files - If you want to ensure a file you are writing to is coherent you may want to flush and/or close that file before exiting

General notes on using threaded scripts:

    The main thing users must know about threaded scripts is that they must have a "main loop". The script will exit normally once it reaches completion so the user must put their script within an infinite loop so that it will continue to run. The general structure of a threaded Python script is as follows:

while( 1 ) : 
  # do something here 

  # wait a little bit and start the loop again 
  event.wait( 400 )

In this example the script is simply waiting a fixed amount of time, 400 milliseconds, before continuing back at the top of the loop. If the script needs to be canceled by a redeploy, a unit shutdown, or (as of 1.5.4) a script change, then this script will simply exit with it hits the event.wait() command.

    If the user wanted to wait indefinitely until an input is changed, they would use event.wait_input_change() here instead.

    If the user needs to clean up in their script they should use one of the two new methods in place of these as necessary.

    It is important to note that if the user does not call any of these event.wait* related methods they will likely cause their nions/nControls to hang at deploy/shutdown/script change time.